func (fs *fileStat) Mode() FileMode     { return fs.mode }
func (fs *fileStat) ModTime() time.Time { return fs.modTime }
func (fs *fileStat) Sys() any           { return fs.sys }

func sameFile(fs1, fs2 *fileStat) bool {
	a := fs1.sys.(*syscall.Dir)
	b := fs2.sys.(*syscall.Dir)
	return a.Qid.Path == b.Qid.Path && a.Type == b.Type && a.Dev == b.Dev

    private Model generateFromModel(Model sourceModel) {
        def tomlFile = Files.createTempFile(tempTomlDir.toPath(), "test-", ".toml")

        def writer = Files.newBufferedWriter(tomlFile)
        writer.withCloseable {
            def tomlWriter = new TomlWriter(it)
            tomlWriter.generate(sourceModel.deps)
        }

        return parse(tomlFile)
    }

    private Model parse(String resourceName) {

    /**
     * Get the model based on the path when resolving the parent based on relativePath.
     *
     * @param from    the requiring model
     * @param pomFile the path to the pomFile
     * @return the model, otherwise {@code null}
     */
    Model getRawModel(Path from, Path pomFile);

    /**
     * Get the model from the reactor based on the groupId and artifactId when resolving reactor dependencies.
     *

    /**
     * Creates a new model source backed by the specified file.
     *
     * @param pomFile The POM file, must not be {@code null}.
     * @deprecated Use {@link #FileModelSource(Path)} instead.
     */
    @Deprecated
    public FileModelSource(File pomFile) {
        super(pomFile);
    }

    /**
     * Creates a new model source backed by the specified file.
     *

        when:
        def link = converter.resolveValue('SomeName#someField', classMetaData, listener)

        then:
        format(link) == '<literal>value</literal>'
        _ * nameResolver.resolve('SomeName', classMetaData) >> 'org.gradle.SomeName'
        _ * repository.find('org.gradle.SomeName') >> otherClass
        _ * otherClass.constants >> [someField: 'value']
    }

        DefaultBinaryStore store = stores.get(storeKey);
        if (store == null || isFull(store) || store.isInUse()) {
            File storeFile = temp.createTemporaryFile("gradle", ".bin");
            storeFile.deleteOnExit();
            store = new DefaultBinaryStore(storeFile);
            stores.put(storeKey, store);
            cleanUpLater.add(store);
        }
        return store;
    }

	}

	coreFile := "core"
	if coreUsesPID {
		coreFile += fmt.Sprintf(".%d", pid)
	}

	// Execute gdb commands.
	args := []string{"-nx", "-batch",
		"-iex", "add-auto-load-safe-path " + filepath.Join(testenv.GOROOT(t), "src", "runtime"),
		"-ex", "backtrace",
		filepath.Join(dir, "a.exe"),
		filepath.Join(dir, coreFile),
	}
	cmd = testenv.Command(t, "gdb", args...)

 */

package gradlebuild.performance.generator

import groovy.xml.XmlParser

class MavenPom {
    final Map<String, MavenScope> scopes = [:]

    MavenPom(File pomFile) {
        def pom = new XmlParser().parse(pomFile)
        pom.dependencies.dependency.each { dep ->
            def scopeElement = dep.scope
            def scopeName = scopeElement ? scopeElement.text() : "runtime"

kind: Foo
apiVersion: company.com/v1
metadata:
  name: test
  labels:
    pruneGroup: "true"
someField: field1
otherField: field2
nestedField:

    private Dependency dependency;

    public InvalidDependencyVersionException(
            String projectId, Dependency dependency, File pomFile, InvalidVersionSpecificationException cause) {
        super(projectId, formatLocationInPom(dependency), dependency.getVersion(), pomFile, cause);
        this.dependency = dependency;
    }

    private static String formatLocationInPom(Dependency dependency) {