}
}

fun publishNormalizedToLocalRepository() {
    val localRepository = layout.buildDirectory.dir("repo")
    val baseName = gradleModule.identity.baseName

    publishing {
        repositories {
            maven {
                name = "local"
                url = uri(localRepository)
            }
        }
        publications {
            create<MavenPublication>("local") {

<!--
This section can be blank if this pull request does not require a release note.

When adding links which point to resources within git repositories, like
KEPs or supporting documentation, please reference a specific commit and avoid
linking directly to the master branch. This ensures that links reference a

    /**
     * Gets the child nodes of this node.
     *
     * @return the child nodes of this node, never {@code null}
     */
    @Nonnull
    List<Node> getChildren();

    /**
     * @return repositories of this node
     */
    @Nonnull
    List<RemoteRepository> getRemoteRepositories();

    /**
     * The repository where this artifact has been downloaded from.
     */
    @Nonnull

 *       These sources support resolving related POMs using the {@link ModelLocator}.</li>
 *   <li>Resolved sources: Used for artifacts that have been resolved by Maven from repositories
 *       (using groupId:artifactId:version coordinates) and downloaded to the local repository.
 *       These sources do not support resolving other sources.</li>
 * </ul>
 *
 * @since 4.0.0
 * @see Source
 */

        variants.named("resources") {
            artifact(futurePluginVersionsDestDir) {
                builtBy(writeFuturePluginVersions)
            }
        }
    }
}

publishing {
    repositories {
        maven {
            name = "test"
            url = uri(localRepository)
        }
    }
}

gradlePlugin {

    public void testBasedir() throws Exception {
        Model model = new Model(org.apache.maven.api.model.Model.newBuilder()
                .version("3.8.1")
                .artifactId("foo")
                .repositories(Collections.singletonList(org.apache.maven.api.model.Repository.newBuilder()
                        .url("file://localhost/${basedir}/temp-repo")
                        .build()))
                .build());

import java.util.SortedSet


/**
 * Tests that check the end-to-end behavior of a Gradle distribution.
 * They can have a locally built Gradle distribution on their runtime classpath
 * and distributions as well as local repositories as additional test inputs
 * to test functionality that requires rea distributions (like the wrapper)
 * or separately published libraries (like the Tooling API Jar).
 */

        }
        Profile p = Profile.newBuilder()
                .id("id" + Long.toHexString(entropy.nextLong()))
                .activation(a)
                .properties(props)
                .repositories(repos)
                .pluginRepositories(pluginRepos)
                .build();

        Profile clone = SettingsUtilsV4.convertToSettingsProfile(SettingsUtilsV4.convertFromSettingsProfile(p));

        assertEquals(1, ((List<?>) pom.getValue("repositories")).size());
        assertEquals("project-remote-repo", pom.getValue("repositories[1]/id"));
        assertEquals("https://project.url/remote", pom.getValue("repositories[1]/url"));
        assertEquals("repo", pom.getValue("repositories[1]/name"));

        assertEquals("test", pom.getValue("build/defaultGoal"));

import gradlebuild.binarycompatibility.transforms.FindGradleClasspath
import gradlebuild.binarycompatibility.transforms.FindGradleJars

plugins {
    id("gradlebuild.module-identity")
}

repositories {
    ['distributions', 'distributions-snapshots'].each { distUrl ->
        ivy {
            name = 'Gradle distributions'
            url = 'https://services.gradle.org'
            patternLayout {