toolchainModels.put("unknown", Collections.singletonList(new ToolchainModel()));
        executionRequest.setToolchains(toolchainModels);
        when(session.getRequest()).thenReturn(executionRequest);

        List<Toolchain> toolchains = toolchainManager.getToolchains(session, "unknown", null);

        assertEquals(0, toolchains.size());

        MavenExecutionRequest req = new DefaultMavenExecutionRequest();
        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");

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

                groupedToolchains.get(model.getType()).add(model);
            }

            request.setToolchains(groupedToolchains);
        }
        return request;
    }

     * @return this request
     * @since 3.3.0
     */
    MavenExecutionRequest setToolchains(Map<String, List<ToolchainModel>> toolchains);

    /**
     *
     * @return all toolchains grouped by type, never {@code null}
     * @since 3.3.0
     */
    Map<String, List<ToolchainModel>> getToolchains();

    /**
     * @since 3.3.0
     * @deprecated use {@link #setRootDirectory(Path)} instead

        return builderId;
    }

    @Override
    public Map<String, List<ToolchainModel>> getToolchains() {
        if (toolchains == null) {
            toolchains = new HashMap<>();
        }
        return toolchains;
    }

    @Override
    public MavenExecutionRequest setToolchains(Map<String, List<ToolchainModel>> toolchains) {
        this.toolchains = toolchains;
        return this;

                return toolchains.get(0);
            }
        }

        return null;
    }

    @Override
    public List<Toolchain> getToolchains(MavenSession session, String type, Map<String, String> requirements) {
        List<ToolchainModel> models = session.getRequest().getToolchains().get(type);

        return selectToolchains(models, type, requirements);
    }

    private List<Toolchain> selectToolchains(

    }

    @Override
    public List<Toolchain> getToolchains(Session session, String type, Map<String, String> requirements)
            throws ToolchainManagerException {
        MavenSession s = InternalMavenSession.from(session).getMavenSession();
        List<org.apache.maven.toolchain.Toolchain> toolchains =
                toolchainManagerPrivate.getToolchains(s, type, requirements);

     * @param requirements the requirements, may be {@code null}
     * @return the matching toolchains, never {@code null}
     * @since 3.3.0
     */
    List<Toolchain> getToolchains(MavenSession session, String type, Map<String, String> requirements);

     * @param type
     * @param requirements
     * @return the selected {@link Toolchain}s
     * @throws ToolchainManagerException if an exception occurs
     */
    @Nonnull
    List<Toolchain> getToolchains(@Nonnull Session session, String type, Map<String, String> requirements);

    /**
     *
     * @param session
     * @param type
     * @return the selected {@link Toolchain}

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

            if (availableToolchains != null) {
                for (ToolchainModel toolchainModel : availableToolchains) {
                    org.apache.maven.toolchain.model.ToolchainModel tm =