List<URI> urls = new ArrayList<URI>();
        for (File file : files) {
            urls.add(file.toURI());
        }
        return urls;
    }

    public Collection<File> getAsFiles() {
        return files;
    }

    public URL[] getAsURLArray() {
        Collection<URL> result = getAsURLs();
        return result.toArray(new URL[result.size()]);
    }

        List<URI> urls = new ArrayList<URI>();
        for (File file : files) {
            urls.add(file.toURI());
        }
        return urls;
    }

    public Collection<File> getAsFiles() {
        return files;
    }

    public URL[] getAsURLArray() {
        Collection<URL> result = getAsURLs();
        return result.toArray(new URL[0]);
    }

    public Collection<URL> getAsURLs() {

    protected abstract TestFile getSha512File()

    abstract TestFile getFile();

    void verifyChecksums() {
        if (server.supportsHash(HttpServer.SupportedHash.SHA1)) {
            def sha1File = getSha1File()
            sha1File.assertIsFile()
            assert HashCode.fromString(sha1File.text) == Hashing.sha1().hashFile(getFile())
        }
        if (server.supportsHash(HttpServer.SupportedHash.MD5)) {

            }
            return new IncrementalNativeCompiler<T>(taskOutputs, compiler, deleter, compileStateCache, incrementalCompilation);
        }

        @Override
        public Set<File> getFiles() {
            List<File> includeRoots = ImmutableList.copyOf(includeDirs);
            compileStateCache = compilationStateCacheFactory.create(taskPath);

            && containsAll(getSystemProperties(), options.getSystemProperties())
            && containsAll(getEnvironment(), options.getEnvironment())
            && getBootstrapClasspath().getFiles().containsAll(options.getBootstrapClasspath().getFiles());
    }

    @Override
    public void checkDebugConfiguration(Iterable<?> arguments) {
        options.checkDebugConfiguration(arguments);
    }

    @Override

            return;
        }

        if (element instanceof Task) {
            visitor.accept((FileCollectionInternal) ((Task) element).getOutputs().getFiles());
        } else if (element instanceof TaskOutputs) {
            visitor.accept((FileCollectionInternal) ((TaskOutputs) element).getFiles());
        } else if (DeferredUtil.isNestableDeferred(element)) {
            Object deferredResult = DeferredUtil.unpackNestableDeferred(element);

    /**
     * Returns the resolved dependency graph as a reference to the root component.
     */
    Provider<ResolvedComponentResult> getRootComponent();

    @Override
    FileCollectionInternal getFiles();

    @Override
    ArtifactCollectionInternal getArtifacts();

     * FileInputStream(getFile())}.
     *
     * @return The input stream. Never returns null. The caller is responsible for closing this stream.
     */
    InputStream open();

    /**
     * Copies the content of this file to an output stream. Generally, calling this method is more performant than
     * calling {@code new FileInputStream(getFile())}.
     *

	pk, fcn uint32
}

func (ts *tstate) readAuxMetaFiles(metafiles string, importpaths map[string]struct{}) error {
	// Unmarshal the information on available aux metafiles into
	// a MetaFileCollection struct.
	var mfc coverage.MetaFileCollection
	data, err := os.ReadFile(metafiles)
	if err != nil {
		return fmt.Errorf("error reading auxmetafiles file %q: %v", metafiles, err)
	}
	if err := json.Unmarshal(data, &mfc); err != nil {

        this.original = original;
        this.derivedFile = derivedFile;
    }

    @Override
    public File getFile() {
        return derivedFile.create();
    }

    @Override
    protected String getDefaultExtension() {
        return original.getExtension() + "." + getFileExtension(getFile().getName());
    }

    @Override
    protected String getDefaultClassifier() {
        return original.getClassifier();