MavenExecutionRequest executionRequest = new DefaultMavenExecutionRequest();
        Map<String, List<ToolchainModel>> toolchainModels = new HashMap<>();
        toolchainModels.put("basic", Arrays.asList(new ToolchainModel(), new ToolchainModel()));
        toolchainModels.put("rare", Collections.singletonList(new ToolchainModel()));
        executionRequest.setToolchains(toolchainModels);

        when(session.getRequest()).thenReturn(req);
        Map<String, List<ToolchainModel>> groupedToolchains = new HashMap<>();
        req.setToolchains(groupedToolchains);

        List<ToolchainModel> basicToolchains = new ArrayList<>();
        ToolchainModel basicToolchainModel = new ToolchainModel();
        basicToolchainModel.setType("basic");
        basicToolchains.add(basicToolchainModel);

    }

    @Override
    public Toolchain getToolchainFromBuildContext(String type, MavenSession session) {
        Map<String, Object> context = retrieveContext(session);

        ToolchainModel model = (ToolchainModel) context.get(getStorageKey(type));

        if (model != null) {
            List<Toolchain> toolchains = selectToolchains(Collections.singletonList(model), type, null);

            throws MavenExecutionRequestPopulationException {
        if (toolchains != null) {
            Map<String, List<ToolchainModel>> groupedToolchains = new HashMap<>(2);

            for (ToolchainModel model : toolchains.getToolchains()) {
                if (!groupedToolchains.containsKey(model.getType())) {
                    groupedToolchains.put(model.getType(), new ArrayList<>());

            }
        };
    }

    @Test
    void testGetModel() {
        ToolchainModel model = new ToolchainModel();
        DefaultToolchain toolchain = newDefaultToolchain(model);
        assertEquals(model, toolchain.getModel());
    }

    @Test
    void testGetType() {
        ToolchainModel model = new ToolchainModel();
        DefaultToolchain toolchain = newDefaultToolchain(model, "TYPE");

package org.apache.maven.toolchain.java;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

import org.apache.maven.toolchain.DefaultToolchain;
import org.apache.maven.toolchain.model.ToolchainModel;
import org.apache.maven.utils.Os;
import org.slf4j.Logger;

/**
 * JDK toolchain implementation.
 *
 * @since 2.0.9, renamed from DefaultJavaToolChain in 3.2.4
 */

        } else {
            List<ToolchainModel> availableToolchains =
                    org.apache.maven.toolchain.model.ToolchainModel.toolchainModelToApiV4(
                            session.getRequest().getToolchains().get(type));

            if (availableToolchains != null) {
                for (ToolchainModel toolchainModel : availableToolchains) {

     */
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        } else if (!(other instanceof ToolchainModel)) {
            return false;
        } else {
            ToolchainModel that = (ToolchainModel) other;
            return java.util.Objects.equals(this.getType(), that.getType())
                && java.util.Objects.equals(this.getProvides(), that.getProvides());

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.toolchain;

import java.util.Map;

import org.apache.maven.toolchain.model.ToolchainModel;

/**
 * a private contract between the toolchains plugin and the components.
 */
public interface ToolchainPrivate extends Toolchain {

    /**

    public static final String KEY_TYPE = "type"; // NOI18N

    private ToolchainModel model;

    /**
     *
     * @param model the model, must not be {@code null}
     * @param logger the logger, must not be {@code null}
     */
    protected DefaultToolchain(ToolchainModel model, Logger logger) {
        this.model = model;
        this.logger = logger;
    }

    /**
     *