builder.endChildren();
    }

    private static void addLocations(TreeFormatter builder, Collection<String> locations) {
        if (locations.isEmpty()) {
            return;
        }
        builder.node("Searched in the following locations");
        builder.startChildren();

        locations.forEach(builder::node);

        builder.endChildren();
    }

    /**

class ArtifactNotFoundExceptionTest extends Specification {
    def "formats message and locations"() {
        def artifactId = Stub(ComponentArtifactIdentifier) {
            getDisplayName() >> "<artifact>"
        }
        def locations = ["http://somewhere", "sftp://elsewhere"]
        def exception = new ArtifactNotFoundException(artifactId, locations)

        expect:

      1);

  // Check the location information.
  std::vector<std::string> locations;
  for (const auto& error : collected_errors) {
    EXPECT_TRUE(error.has_location());
    locations.push_back(error.location().DebugString());
  }

  EXPECT_THAT(locations, Each(testing::HasSubstr("CALLSITELOC")));
  EXPECT_THAT(locations, Each(testing::HasSubstr(input_file)));

        StringBuilder builder = new StringBuilder();
        builder.append(String.format("Could not find %s.", artifact.getDisplayName()));
        if (!locations.isEmpty()) {
            builder.append(String.format("%nSearched in the following locations:"));
            for (String location : locations) {
                builder.append(String.format("%n    %s", location));

    }

    private long getVersion(String location) {
        return versionHierarchyRoot.getVersion(location)
    }

    List<String> locationWithAncestors(String location) {
        (location.split('/') as List)
            .findAll {!it.empty }
            .inits().collect { "/${it.join('/')}".toString() }
    }

    private void updateVersions(String... locations) {

        List<InternalLocation> locations,
        List<InternalSolution> solutions,
        InternalAdditionalData additionalData,
        @Nullable InternalFailure failure
    ) {
        this.definition = definition;
        this.details = details;
        this.contextualLabel = contextualLabel;
        this.locations = locations;
        this.solutions = solutions;

        then:
        directories.size() == 2
        directories*.location.toSorted() == [
            candidates.file("11.0.6.hs-adpt"),
            candidates.file("14")
        ]
        directories*.source.unique() == ["Common Linux Locations"]
    }

    def "supplies installations for multiple locations"() {
        given:

        this
    }

    ResourceGeneratingProcessorFixture withOutputLocations(String... locations) {
        outputLocations = Arrays.asList(locations)
        this
    }

    ResourceGeneratingProcessorFixture withOutputLocations(List<String> locations) {
        outputLocations = locations
        this
    }

    String getGeneratorCode() {
        def outputs = outputLocations.collect { """

    }

    def "locations are as expected for non-standard settings locations available for scripts"() {
        def customSettingsPath = "custom-subdir/custom-settings.gradle"
        def customSettingsFile = testDirectory.file(customSettingsPath)
        def customSettingsDir = customSettingsFile.parentFile
        // setting a custom settings location is deprecated
        executer.noDeprecationChecks()

            definition.severity == Severity.WARNING
            definition.documentationLink != null
            locations.size() == 2
            locations[0].path == "build file 'build.gradle'"
            locations[0].line == 2
            locations[1].path == "build file '${buildFile.absolutePath}'"
            locations[1].line == 2
        }

        when:
        configurationCacheRunLenient '-Pdummy=true', 'run'