case hasPrefix(key, attrExperimental):
		return validateMapKey(key)
	case isEqual(key, attrDestNamespace):
		return fmt.Errorf("attribute %s is replaced by the metadata.namespace", key)
	case hasPrefix(key, attrDestLabel):
		return fmt.Errorf("attribute %s is replaced by the workload selector", key)
	case isEqual(key, attrDestName, attrDestUser):
		return fmt.Errorf("deprecated attribute %s: only supported in v1alpha1", key)

	"istio.io/istio/pkg/test/util/file"
)

const (
	ExternalSvc      = "external"
	ExternalHostname = "fake.external.com"
)

type External struct {
	// Namespace where external echo app will be deployed
	Namespace namespace.Instance

	// All external echo instances with no sidecar injected
	All echo.Instances
}

func (e External) Build(t resource.Context, b deployment.Builder) deployment.Builder {

/**
 * The meta-data for a component that is resolved from a module in a binary repository.
 *
 * <p>Implementations of this type should be immutable and thread safe.</p>
 *
 * This type is being replaced by several other interfaces. Try to avoid this interface.
 * @see ComponentGraphResolveMetadata
 * @see ModuleComponentGraphResolveMetadata
 * @see ComponentArtifactResolveMetadata
 */

	// call f, and the second would return immediately, without
	// waiting for the first's call to f to complete.
	// This is why the slow path falls back to a mutex, and why
	// the o.done.Store must be delayed until after f returns.

	if o.done.Load() == 0 {
		// Outlined slow-path to allow inlining of the fast-path.
		o.doSlow(f)
	}
}

func (o *Once) doSlow(f func()) {
	o.m.Lock()
	defer o.m.Unlock()

 * there is a class-level lower bound for both versions.
 *
 * In addition, in version 6.6 the deprecated {@code DependencySubstitutions#with(ComponentSelector)} method
 * was removed, to be replaced by {@code #using(ComponentSelector)} so there are 2 versions of tests
 * present using either of those methods - pre and post Gradle 6.6.  And when the TAPI or Gradle versions

	if labels == nil {
		return labelMap(nil)
	}
	return *labels
}

// labelMap is the representation of the label set held in the context type.
// This is an initial implementation, but it will be replaced with something
// that admits incremental immutable modification more efficiently.
type labelMap map[string]string

// String satisfies Stringer and returns key, value pairs in a consistent
// order.

            // This check is here for historical reasons, as removing it would be a breaking change.
            // We should just leave this here, since this observation mechanism is being replaced anyway.
            if (projectComponentId.getBuild().equals(thisBuild)) {
                resolvedProjectConfigurations.add(new ResolvedProjectConfiguration(projectComponentId.getIdentityPath(), node.getMetadata().getName()));

                String reason = replacement.getReason();
                ComponentSelectionDescriptorInternal moduleReplacement = ComponentSelectionReasons.SELECTED_BY_RULE.withDescription(Describables.of(identifier, "replaced with", replacement.getTarget()));
                if (reason != null) {
                    moduleReplacement = moduleReplacement.withDescription(Describables.of(reason));
                }

        when:
        result = executer
                .withTasks("compileJava")
                .run()

        then:
        !result.plainTextOutput.matches("(?s).*The existing installation will be replaced by the new download.*")
    }

    @Requires(IntegTestPreconditions.DifferentJdksFromMultipleVendors)
    def "multiple subprojects with different toolchain definitions"() {
        given:

            sb.append("NOT (");
            sb.append(join(exclusions, " OR "));
            sb.append(")");
        }

        return sb.toString();
    }

    // Can be replaced with String.join when workers are updated to run in JDK 8.
    private static String join(Set<String> strings, String delimiter) {
        StringBuilder result = new StringBuilder();