List<String> getAttempted();

    /**
     * Adds a location that was used to build this result. This is used for diagnostic messages and logging.
     */
    void attempted(String locationDescription);

    /**
     * Adds a location that was used to build this result. This is used for diagnostic messages and logging.
     */
    void attempted(ExternalResourceName location);

    /**

                        matcher.appendTail(resolvedValue);
                        locations.add(resolvedValue.toString());
                    }
                }
                return locations.stream()
                    .map(jdkHome -> InstallationLocation.autoDetected(new File(jdkHome), getSourceName()))
                    .collect(Collectors.toSet());

        // Keep only snapshots we can trust
        return retainOnlyMatchingSnapshots(newRoot, invalidator, snapshot -> {
            // Keep everything in immutable locations, because Gradle makes sure
            // to update the VFS when it updates those locations
            if (immutableLocationsFilter.test(snapshot.getAbsolutePath())) {
                return true;
            }

	"path/filepath"
	"runtime"
	"testing"
	"time"

	. "cmd/compile/internal/types2"
)

func TestSelf(t *testing.T) {
	testenv.MustHaveGoBuild(t) // The Go command is needed for the importer to determine the locations of stdlib .a files.

	files, err := pkgFiles(".")
	if err != nil {
		t.Fatal(err)
	}

	conf := Config{Importer: defaultImporter()}
	_, err = conf.Check("cmd/compile/internal/types2", files, nil)

        then:
        failure.assertHasCause("Could not resolve all dependencies for configuration ':compile'.")
        failure.assertHasCause("""Could not find any version that matches test:test:2.0.
Searched in the following locations:
  - Git repository at ${repo.url}
Required by:
    project :""")

        when:
        repoSettingsFile.replace("version = '1.1'", "version = '2.0'")
        repo.commit("v2")

    }

    def "processors can generate identical resources in different locations"() {
        given:
        def locations = [StandardLocation.SOURCE_OUTPUT.toString(), StandardLocation.NATIVE_HEADER_OUTPUT.toString(), StandardLocation.CLASS_OUTPUT.toString()]
        withProcessor(new ResourceGeneratingProcessorFixture().withOutputLocations(locations).withDeclaredType(IncrementalAnnotationProcessorType.AGGREGATING))

    abstract Class<? extends LanguageSourceSet> getSourceSetClass()

    abstract Class<? extends Task> getCompileTaskClass()

    abstract String getPluginName()

    def "creates source set with conventional locations for components"() {
        when:
        dsl {
            pluginManager.apply pluginClass

            model {
                components {
                    exe(NativeExecutableSpec)

        /**
         * Resolves location of the outputs of this result for a given input artifact.
         *
         * Produced outputs don't need to be resolved to locations, since they are already resolved to absolute paths in the workspace.
         * The relative paths of selected parts of the input artifact need to resolved based on the provided input artifact location.
         */

    ImmutableSet<LocationInfo> locations = locationsFrom(classloader);

    // Add all locations to the scanned set so that in a classpath [jar1, jar2], where jar1 has a
    // manifest with Class-Path pointing to jar2, we won't scan jar2 twice.
    Set<File> scanned = new HashSet<>();
    for (LocationInfo location : locations) {
      scanned.add(location.file());
    }

    // Scan all locations

// It can be used to consistently use the same start time instead of calling time.Now()
// in multiple locations and ending up with minor time deviations.
var startTime time.Time

func init() {
	startTime = time.Now()
}

// StartTimeUTC returns startTime with its location set to UTC.
func StartTimeUTC() time.Time {
	return startTime.UTC()