*/
    @Nonnull
    default Language getLanguage() {
        return getPackaging().language();
    }

    /**
     * Returns the project POM artifact, which is the artifact of the POM of this project. Every project have a POM
     * artifact, even if the existence of backing POM file is NOT a requirement (i.e. for some transient projects).
     *
     * @see org.apache.maven.api.services.ArtifactManager#getPath(Artifact)
     */
    @Nonnull

        super(parent);
        this.attrib = attrib;
    }

    @Override
    public int compareChildNodePointers(NodePointer pointer1, NodePointer pointer2) {
        // should never happen because attributes have no children
        return 0;
    }

    @Override
    public Object getValue() {
        return attrib.getValue();
    }

    @Override
    public Object getBaseValue() {
        return attrib;

                if (propValue.startsWith("!")) {
                    reverseValue = true;
                    propValue = propValue.substring(1);
                }

                // we have a value, so it has to match the system value...
                boolean result = propValue.equals(sysValue);

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

        plugin.setArtifactId( "maven-surefire-plugin" );
        plugin.setVersion( "2.4.2" );

        // The project has already been fully interpolated so getting the raw mojoDescriptor is not going to have the processes configuration.
        MojoDescriptor mojoDescriptor = pluginManager.getMojoDescriptor( plugin, goal, session.getLocalRepository(), session.getCurrentProject().getPluginArtifactRepositories() );

            pomArtifact = rel.pomArtifact;

            relocatedArtifact = rel.relocatedArtifact;

            if (rel.project == null) {
                // When this happens we have a Maven 1.x POM, or some invalid POM.
                // It should have never found its way into Maven 2.x repository but it did.
                dependencies = Collections.emptyList();
            } else {

     * Whether module hierarchy was detected. If false, then package hierarchy is assumed.
     * In a package hierarchy, the {@linkplain #descriptors} map has either zero or one entry.
     * In a module hierarchy, the descriptors map may have an arbitrary number of entries,
     * including one (so the map size cannot be used as a criterion).
     *
     * @see #isModuleHierarchy()
     */
    private final boolean isModuleHierarchy;

    /**

        requireNonNull(pluginBindings);
        final int len = pluginBindings.length;
        if (len < 2 || len % 2 != 0) {
            throw new IllegalArgumentException("Plugin bindings must have more than 0, even count of elements");
        }

        HashMap<String, LifecyclePhase> lifecyclePhaseBindings = new HashMap<>(len / 2);
        for (int i = 0; i < len; i = i + 2) {

     * be able to accept <code>relative</code> parameter values that
     * <ul>
     * <li>use either / or \ file path separator,</li>
     * <li>have .. parent directory references,</li>
     * <li>point either at file or directory.</li>
     * </ul>
     *
     * @param relative is the path of the requested source relative to this source

            projectBuilds = buildListCalculator.calculateProjectBuilds(session, taskSegments);

            if (projectBuilds.isEmpty()) {
                throw new NoGoalSpecifiedException("No goals have been specified for this build."
                        + " You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal> or"

/**
 * Default abstract toolchain implementation, to be used as base class for any toolchain implementation
 * to avoid rewriting usual code.
 *
 * @since 2.0.9
 */
public abstract class DefaultToolchain // should have been AbstractToolchain...
implements Toolchain, ToolchainPrivate {
    private final Logger logger;

    private String type;

    private Map<String, RequirementMatcher> provides = new HashMap<>();