#*    *##if ( $MITLicenseNames.contains( $license.name ) )
#*      *##set ( $spdx = 'MIT' )
#*    *##elseif ( $license.name == "Eclipse Public License, Version 1.0" )
#*      *##set ( $spdx = 'EPL-1.0' )
#*    *##elseif ( $license.url.contains( "www.apache.org/licenses/LICENSE-2.0" ) )
#*      *##set ( $spdx = 'Apache-2.0' )
#*    *##else
#*      *### unrecognized license will require analysis to know obligations

                    }
                }
            } else if (exception instanceof MojoFailureException) {
                reference = MojoFailureException.class.getSimpleName();
            } else if (exception instanceof LinkageError) {
                reference = LinkageError.class.getSimpleName();
            } else if (exception instanceof PluginExecutionException) {

        List<String> roots;
        if (nonNull(scope, "scope") == ProjectScope.MAIN) {
            roots = prj.getCompileSourceRoots();
        } else if (scope == ProjectScope.TEST) {
            roots = prj.getTestCompileSourceRoots();
        } else {
            throw new IllegalArgumentException("Unsupported scope " + scope);
        }
        return roots.stream()
                .map(Paths::get)

            return target;
        } else if (target == null) {
            return source;
        }

        Map<Object, InputLocation> locations;
        Map<Object, InputLocation> sourceLocations = source.locations;
        Map<Object, InputLocation> targetLocations = target.locations;
        if (sourceLocations == null) {
            locations = targetLocations;
        } else if (targetLocations == null) {

        } else if (Artifact.SCOPE_COMPILE.equals(originalScope) && Artifact.SCOPE_COMPILE.equals(inheritedScope)) {
            // added to retain compile scope. Remove if you want compile inherited as runtime
            effectiveScope = Artifact.SCOPE_COMPILE;
        } else if (Artifact.SCOPE_TEST.equals(inheritedScope)) {
            effectiveScope = Artifact.SCOPE_TEST;

        } else if (requestType.equals(MetadataResolutionRequestTypeEnum.classpathRuntime)) {
            return conflictResolver.resolveConflicts(getGraph(), ArtifactScopeEnum.runtime);
        } else if (requestType.equals(MetadataResolutionRequestTypeEnum.classpathTest)) {
            return conflictResolver.resolveConflicts(getGraph(), ArtifactScopeEnum.test);

    @Override
    public String getGroupId() {
        if (groupId != null) {
            return groupId;
        } else {
            return artifact.getGroupId();
        }
    }

    @Override
    public String getArtifactId() {
        if (artifactId != null) {
            return artifactId;
        } else {
            return artifact.getArtifactId();
        }
    }

    @Override

                        retVal += expr.substring(index + 1, lastIndex + 1);
                    } else {
                        Object subResult = evaluate(expr.substring(index, lastIndex + 1));

                        if (subResult != null) {
                            retVal += subResult;
                        } else {
                            retVal += "$" + expr.substring(index + 1, lastIndex + 1);

                if (reverseValue) {
                    return !result;
                } else {
                    return result;
                }
            } else {
                boolean result = sysValue != null && !sysValue.isEmpty();

                if (reverseName) {
                    return !result;
                } else {
                    return result;
                }
            }
        }

                    message += " from repository " + artifact.getRepository().getId();
                } else {
                    message += " from local repository";
                }
                getLogger().debug(message);
            } else {
                // Locally installed file is newer, don't use the resolved version