"groups" : [ {
      "testProject" : "excludeRuleMergingBuild",
      "coverage" : {
        "per_commit" : [ "linux" ]
      }
    } ]
  }, {
    "testId" : "org.gradle.performance.regression.corefeature.LargeDependencyGraphPerformanceTest.resolve large dependency graph (parallel = false, locking = true)",

import javax.inject.Named;
import javax.inject.Singleton;

import java.util.Map;

import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.model.Plugin;

      return ".";
    }

    // split the path apart
    Iterable<String> components = Splitter.on('/').omitEmptyStrings().split(pathname);
    List<String> path = new ArrayList<>();

    // resolve ., .., and //
    for (String component : components) {
      switch (component) {
        case ".":
          continue;
        case "..":
          if (path.size() > 0 && !path.get(path.size() - 1).equals("..")) {

            if (moduleName.isEmpty()) {
                continue;
            }

            Path moduleDirectory = baseDirectory.resolve(moduleName);
            Path modulePomPath = moduleDirectory.resolve(POM_XML);

            if (Files.exists(modulePomPath) && !pomMap.containsKey(modulePomPath)) {
                Document modulePom = loadPom(modulePomPath);

public class DefaultRootLocator implements RootLocator {

    @Override
    public boolean isRootDirectory(Path dir) {
        if (Files.isDirectory(dir.resolve(".mvn"))) {
            return true;
        }
        // we're too early to use the modelProcessor ...
        Path pom = dir.resolve("pom.xml");
        try (InputStream is = Files.newInputStream(pom)) {

		//
		// We therefore perform a heal check.
		// If that doesn't bring it back we remove the folder and assume it was deleted.
		// This means that the next run will not look for it.
		// How to resolve results.
		resolver := metadataResolutionParams{
			dirQuorum: f.disksQuorum,
			objQuorum: f.disksQuorum,
			bucket:    "",
			strict:    false,
		}

		healObjectsPrefix := color.Green("healObjects:")

        Files.writeString(mavenUserProps, "${includes} = ?${session.rootDirectory}/.mvn/maven-user.properties\n");
        Path rootDirectory = fs.getPath("C:\\myRootDirectory");
        Path topDirectory = rootDirectory.resolve("myTopDirectory");
        Path mvn = rootDirectory.resolve(".mvn");
        Files.createDirectories(mvn);
        Files.writeString(

                } else {
                    toResolve.add(() -> resolvePlugin(session, project.getRemotePluginRepositories(), plugin));
                }
            }));

            // Eagerly resolve all plugins in parallel
            toResolve.parallelStream().forEach(Runnable::run);

            // Keep track of phase aliases

    )
    server.enqueue(MockResponse(body = "ABCDE"))
    val client =
      client
        .newBuilder()
        .proxy(server.proxyAddress)
        .build()

    val url = server.url("/").resolve("//android.com/foo")!!
    val port =
      when (url.scheme) {
        "https" -> 443
        "http" -> 80
        else -> error("unexpected scheme")
      }

  "scenario" : "org.gradle.performance.regression.corefeature.LargeDependencyGraphPerformanceTest.resolve large dependency graph (parallel = false, locking = false)",
  "durations" : [ {
    "testProject" : "excludeRuleMergingBuild",
    "linux" : 233
  } ]
}, {
  "scenario" : "org.gradle.performance.regression.corefeature.LargeDependencyGraphPerformanceTest.resolve large dependency graph (parallel = false, locking = true)",
  "durations" : [ {