}

    public ParameterMetaData addParameter(String name, TypeMetaData type) {
        ParameterMetaData param = new ParameterMetaData(name);
        param.setType(type);
        parameters.add(param);
        return param;
    }

    public String getSignature() {
        StringBuilder builder = new StringBuilder();
        builder.append(returnType.getSignature());
        builder.append(' ');

    private final List<Problem> problems;

    /**
     * Creates a new exception with the specified problems.
     *
     * @param problems The problems that cause this exception, must not be {@code null}.
     */
    public ToolchainsBuildingException(List<Problem> problems) {
        super(toMessage(problems));

        this.problems = new ArrayList<>();
        if (problems != null) {

        return Stream.of(
                Arguments.of(false, new String[] {}, false),
                Arguments.of(true, new String[] {}, true),
                Arguments.of(true, new String[] {"--force-interactive"}, false),
                Arguments.of(true, new String[] {"--force-interactive", "--non-interactive"}, false),
                Arguments.of(true, new String[] {"--force-interactive", "--batch-mode"}, false),

                throw new InvalidVersionSpecificationException(
                        "Only fully-qualified sets allowed in multiple set scenario: " + spec);
            } else {
                version = new DefaultArtifactVersion(process);
                restrictions.add(Restriction.EVERYTHING);
            }
        }

        cached = new VersionRange(version, restrictions);

    private final Map<String, T> classes = new TreeMap<>();

    @SuppressWarnings("unchecked")
    public void load(File repoFile) {
        try {
            FileInputStream inputStream = new FileInputStream(repoFile);
            try {
                ObjectInputStream objInputStream = new ObjectInputStream(new BufferedInputStream(inputStream));
                classes.clear();

        if (pluginFile == null) {
            throw new IllegalStateException("plugin main artifact has not been resolved for " + getId());
        }

        if (pluginFile.isFile()) {
            try {
                return new URL("jar:" + pluginFile.toURI() + "!/" + descriptor).openStream();
            } catch (MalformedURLException e) {
                throw new IllegalStateException(e);
            }
        } else {

    private DuplicateMerger merger = new DuplicateMerger();

    @Override
    public void mergeDuplicates(Model model, ModelBuildingRequest request, ModelProblemCollector problems) {
        Build build = model.getBuild();
        if (build != null) {
            List<Plugin> plugins = build.getPlugins();
            Map<Object, Plugin> normalized = new LinkedHashMap<>(plugins.size() * 2);

        List<Element> header = children(tr, "td");
        if (header.size() < 1) {
            throw new RuntimeException(String.format("Expected at least 1 <td> in <thead>/<tr>, found: %s", header));
        }
        Map<String, Element> inheritedValueTitleMapping = new HashMap<String, Element>();
        List<Element> valueTitles = new ArrayList<Element>();
        for (int i = 1; i < header.size(); i++) {

        if (isWindows()) {
            return new String[]{"powershell", "-Command", "\"Get-CimInstance Win32_Process | ForEach-Object { \\\"$($_.CommandLine) $($_.ProcessId)\\\" }\""};
        } else if (isMacOS()) {
            return new String[]{"ps", "x", "-o", "pid,command"};
        } else if (isAlpine()) {
            return new String[]{"ps", "x", "-o", "pid,args"};
        } else {

            plan.requiredStep(project, "after:test-resources").addMojo(new MojoExecution(null), 0);
            plan.requiredStep(project, "compile").addMojo(new MojoExecution(null), 0);
            plan.requiredStep(project, "test-compile").addMojo(new MojoExecution(null), 0);
            plan.requiredStep(project, "test").addMojo(new MojoExecution(null), 0);