LifecycleMojo lifecycleMojo = new LifecycleMojo();
        lifecycleMojo.setGoal(s.trim());
        return lifecycleMojo;
    };

    @Override
    public String toString() {
        return Optional.ofNullable(getMojos()).orElse(Collections.emptyList()).stream()
                .map(LifecycleMojo::getGoal)
                .collect(Collectors.joining(","));
    }

    @Deprecated

            public Optional<Source> getInstallationToolchainsSource() {
                return Optional.ofNullable(installationToolchainsSource);
            }

            @Nonnull
            @Override
            public Optional<Source> getUserToolchainsSource() {
                return Optional.ofNullable(userToolchainsSource);
            }

            @Override
            public boolean equals(Object o) {

    @Override
    public Language language() {
        return (language != null) ? language : SourceRoot.super.language();
    }

    @Override
    public Optional<String> module() {
        return Optional.ofNullable(moduleName);
    }

    @Override
    public PathMatcher matcher(Collection<String> defaultIncludes, boolean useDefaultExcludes) {
        return null; // Not used for this test.
    }

    @Test

        return Objects.equals(p, packaging);
    }

    private static Optional<String> getActivationPackaging(org.apache.maven.model.Profile profile) {
        return Optional.ofNullable(profile)
                .map(org.apache.maven.model.Profile::getDelegate)
                .map(Profile::getActivation)
                .map(Activation::getPackaging);
    }

    }

    @Override
    public <T> T lookup(Class<T> type, String name) {
        return lookup(type);
    }

    @Override
    public <T> Optional<T> lookupOptional(Class<T> type) {
        return Optional.ofNullable(type.cast(components.get(type)));
    }

    @Override
    public <T> Optional<T> lookupOptional(Class<T> type, String name) {
        return lookupOptional(type);
    }

    @Override

    }

    private Optional<String> extractRequiredJavaVersion(PlexusConfiguration c) {
        return Optional.ofNullable(c.getChild("requiredJavaVersion")).map(PlexusConfiguration::getValue);
    }

    private Optional<String> extractRequiredMavenVersion(PlexusConfiguration c) {
        return Optional.ofNullable(c.getChild("requiredMavenVersion")).map(PlexusConfiguration::getValue);
    }

        }
        Path path = paths.get(id);
        if (path == null && artifact instanceof DefaultArtifact defaultArtifact) {
            path = defaultArtifact.getArtifact().getPath();
        }
        return Optional.ofNullable(path);
    }

    @Override
    public void setPath(@Nonnull ProducedArtifact artifact, Path path) {
        String id = id(requireNonNull(artifact, "artifact cannot be null"));

            @Nonnull
            @Override
            public Optional<Path> getPath() {
                return Optional.ofNullable(path);
            }

            @Nonnull
            @Override
            public Optional<Source> getSource() {
                return Optional.ofNullable(source);
            }

            @Override
            public boolean isAllowStubModel() {

        }
        return null;
    }

    @Nonnull
    public static Path findMandatoryRoot(Path topDirectory) {
        requireNonNull(topDirectory, "topDirectory");
        return getCanonicalPath(Optional.ofNullable(
                        ServiceLoader.load(RootLocator.class).iterator().next().findMandatoryRoot(topDirectory))
                .orElseThrow());
    }

            @Nonnull
            @Override
            public Optional<Project> getProject() {
                return Optional.ofNullable(project);
            }

            @Nonnull
            @Override
            public Optional<Artifact> getRootArtifact() {
                return Optional.ofNullable(rootArtifact);
            }

            @Nonnull
            @Override