.fileComment("This is a general purpose Gradle build.\n"
                + documentationRegistry.getSampleForMessage())
            .create(settings.getTarget())
            .generate();
    }

import java.util.List;

public interface DependencySubstitutionInternal extends DependencySubstitution {
    void useTarget(Object notation, ComponentSelectionDescriptor ruleDescriptor);

    ComponentSelector getTarget();

    List<ComponentSelectionDescriptorInternal> getRuleDescriptors();

    boolean isUpdated();

    ArtifactSelectionDetailsInternal getArtifactSelectionDetails();

        Replacement(ModuleIdentifier target, @Nullable String reason) {
            this.target = target;
            this.reason = reason;
        }

        public ModuleIdentifier getTarget() {
            return target;
        }

        @Nullable
        public String getReason() {
            return reason;
        }
    }

            if (requirement.getProjectPath() == null || requirement.getProjectPath().isEmpty()) {
                requirement = requirement.withProjectPath(nativeBinaryResolveResult.getTarget().getProjectPath());
            }
            resolution.setRequirement(requirement);
        }
        delegate.resolve(nativeBinaryResolveResult);
    }

        }
    }

    /**
     * Returns the Ant target to execute.
     */
    @Internal
    public Target getTarget() {
        return target;
    }

    /**
     * Sets the Ant target to execute.
     */
    public void setTarget(Target target) {
        this.target = target;
    }

    /**
     * Returns the Ant project base directory to use when executing the target.

    public void generate(InitSettings settings, BuildContentGenerationContext buildContentGenerationContext) {
        if (!settings.isUseIncubatingAPIs()) {
            return;
        }
        File file = settings.getTarget().file("gradle.properties").getAsFile();
        try (PrintWriter writer = new PrintWriter(new FileWriter(file))) {
            if (settings.isWithComments()) {

     *
     * @param version version to use
     */
    void useVersion(@Nullable String version);

    /**
     * The target plugin request to use.
     */
    PluginRequest getTarget();

@TargetVersions(["1.5"])
class UnsupportedJavaVersionCrossCompilationIntegrationTest extends MultiVersionIntegrationSpec {
    JavaVersion getJavaVersion() {
        JavaVersion.toVersion(version)
    }

    JavaInfo getTarget() {
        return AvailableJavaHomes.getJdk(javaVersion)
    }

    def setup() {
        Assume.assumeTrue(target != null)
        def java = TextUtil.escapeString(target.getJavaExecutable())

        return new IncludedRootBuildTaskReference(rootBuild, path);
    }

    @Override
    public BuildState getTarget() {
        return rootBuild;
    }

    private static class IncludedRootBuildTaskReference implements TaskReference, TaskDependencyContainer {
        private final String taskPath;

            generator.generate(settings, buildContentGenerationContext);
        }
        generator.generate(settings, buildContentGenerationContext);
        VersionCatalogGenerator.create(settings.getTarget()).generate(buildContentGenerationContext, settings.isWithComments());
    }