project = locatePom(project);
        }
        if (Files.isDirectory(project)) {
            Path pom = project.resolve("pom.xml");
            return Files.isRegularFile(pom) ? pom : null;
        } else if (Files.isRegularFile(project)) {
            return project;
        } else {
            return null;
        }
    }

      assertFalse(MoreFiles.isRegularFile().apply(symlinkToDir));

      assertFalse(MoreFiles.isDirectory().apply(symlinkToFile));
      assertTrue(MoreFiles.isRegularFile().apply(symlinkToFile));

      assertFalse(MoreFiles.isDirectory(NOFOLLOW_LINKS).apply(symlinkToDir));
      assertFalse(MoreFiles.isRegularFile(NOFOLLOW_LINKS).apply(symlinkToFile));
    }
  }

  /**

                        installationToolchainsFile != null && Files.isRegularFile(installationToolchainsFile)
                                ? Source.fromPath(installationToolchainsFile)
                                : null)
                .userToolchainsSource(
                        userToolchainsFile != null && Files.isRegularFile(userToolchainsFile)
                                ? Source.fromPath(userToolchainsFile)

        // maven.config; if exists
        Path mavenConfig = context.rootDirectory != null ? context.rootDirectory.resolve(".mvn/maven.config") : null;
        if (mavenConfig != null && Files.isRegularFile(mavenConfig)) {
            result.add(parseMavenConfigOptions(mavenConfig));
        }
        return result;
    }

    protected O parseMavenCliOptions(List<String> args) throws ParserException {

                        // gathered with problem collector
                    }
                }
            }

            private Model findRawModel(Path from, Path p) {
                if (!Files.isRegularFile(p)) {
                    throw new IllegalArgumentException("Not a regular file: " + p);
                }

                if (!addEdge(from, p, problems)) {
                    return null;
                }

    }

    private File findInProjectLocalRepository(Artifact artifact) {
        Path target = getArtifactPath(artifact);
        return Files.isRegularFile(target) ? target.toFile() : null;
    }

    /**
     * We are interested in project success events, in which case we call
     * the {@link #installIntoProjectLocalRepository(MavenProject)} method.

    protected void invoke(Path cwd, Collection<String> goals) throws Exception {
        // works only in recent Maven4
        Assumptions.assumeTrue(
                Files.isRegularFile(Paths.get(System.getProperty("maven.home"))
                        .resolve("conf")
                        .resolve("maven.properties")),
                "${maven.home}/conf/maven.properties must be a file");

        Path pomPath = pomFile.resolveSibling(relativePath).normalize();
        if (Files.isDirectory(pomPath)) {
            pomPath = context.locate(pomPath);
        }

        if (pomPath == null || !Files.isRegularFile(pomPath)) {
            return Optional.empty();
        }

        Optional<RelativeProject> mappedProject = Optional.ofNullable(context.getRawModel(pomFile, pomPath.normalize()))

                && "".equals(artifact.getClassifier())
                && artifact.getPath() != null) {
            Path artifactPath = artifact.getPath();
            if (Files.isRegularFile(artifactPath)) {
                try (JarFile artifactJar = new JarFile(artifactPath.toFile(), false)) {
                    ZipEntry pluginDescriptorEntry = artifactJar.getEntry(PLUGIN_DESCRIPTOR_LOCATION);

        if (mavenOptions.altUserSettings().isPresent()) {
            userSettingsFile =
                    context.cwdResolver.apply(mavenOptions.altUserSettings().get());

            if (!Files.isRegularFile(userSettingsFile)) {
                throw new FileNotFoundException("The specified user settings file does not exist: " + userSettingsFile);
            }
        } else {