} catch (AtomicMoveNotSupportedException e) {
                    // In theory, we should never hit this code, but some more obscure file systems or OSes may not support atomic moves
                    LOGGER.info("Failed to use an atomic move for unpacked JDK from {} to {}. Will try to copy instead.", unpackedRoot.dir, installFolder, e);

			Annotations: map[string]string{
				// Add always-reject annotation. For now, we are invalid for two reasons: missing `spec.servers`, and this
				// annotation. In the future, the CRD will reject a missing `spec.servers` before we hit the webhook, so we will
				// only have that annotation. For backwards compatibility, we keep both methods for some time.
				constants.AlwaysReject: "true",
			},
		},
		Spec: networking.Gateway{},
	}

	for _, fqdn := range conf.nameList(name) {
		p, server, err = r.tryOneName(ctx, conf, fqdn, qtype)
		if err == nil {
			break
		}
		if nerr, ok := err.(Error); ok && nerr.Temporary() && r.strictErrors() {
			// If we hit a temporary error with StrictErrors enabled,
			// stop immediately instead of trying more names.
			break
		}
	}
	if err == nil {
		return p, server, nil
	}
	if err, ok := err.(*DNSError); ok {

            return true
        })
    }

    @Override
    AbstractIntegrationSpec withBuildCache() {
        // When configuration cache is enabled, the task graph for cache-hit builds will be loaded from the cache and tasks will run in parallel and start in an arbitrary order
        // Use max-workers=1 to force non-parallel execution and the tasks to run in the specified order

		}
		units := make([]extcu, 0, len(p.unitTable))
		for u := range p.unitTable {
			units = append(units, u)
		}

		// Within a package, sort the units, then walk through the
		// sorted array. Each time we hit a new function, emit the
		// summary entry for the previous function, then make one last
		// emit call at the end of the loop.
		p.sortUnits(units)
		fname := ""
		ffile := ""
		flit := false
		var fline uint32

each node contains

 - type of delimiter [ ![ _ *
 - number of delimiters
 - active or not
 - potential opener, potential closer, or obth

when a ] is hit, call look for link or image
when end is hit, call process emphasis

look for link or image:

	find topmost [ or ![
	if none, emit literal ]
	if its inactive, remove and emit literal ]

// the cache tokens are returned to allow future writes to the cache.
// This code will only trigger a cache hit if all subset clusters are present. This simplifies the code a bit,
// as the non-subset and subset cluster generation are tightly coupled, in exchange for a likely trivial cache hit rate impact.
func (cb *ClusterBuilder) getAllCachedSubsetClusters(clusterKey clusterCache) ([]*discovery.Resource, bool) {

						"external.echo1.svc.cluster.local_naked.echo1.svc.cluster.local_vm.echo1.svc.cluster.local": 2,
					},
					"vm.echo1.svc.cluster.local": {
						// VM cannot hit external services (https://github.com/istio/istio/issues/27154)
						"b.echo1.svc.cluster.local_naked.echo1.svc.cluster.local_vm.echo1.svc.cluster.local": 2,
					},
				},
			},
		}

        when:
        configurationCacheRun 'help'

        then:
        outputContains('In script plugin')
        buildLogicBuiltAndWorkGraphStoredAndLoaded()

        // TODO - should get a cache hit for this build (https://github.com/gradle/gradle/issues/23267)
        when:
        configurationCacheRun 'help'

        then:
        buildLogicBuiltAndWorkGraphStoredAndLoaded()

        when:

        when:
        configurationCacheRun()

        then:
        // TODO(mlopatkin) This behavior is correct but suboptimal, as we're never going to have a cache hit.
        //  We may want to warn the user about it.
        configurationCache.assertStateStored()
        outputContains("configuration value = someValue")
        outputContains("execution value = someValue")
    }