assertEquals(1, result.getEffectiveToolchains().getToolchains().size());
        assertEquals(
                "TYPE", result.getEffectiveToolchains().getToolchains().get(0).getType());
        assertEquals(
                "user_value",
                result.getEffectiveToolchains()
                        .getToolchains()
                        .get(0)
                        .getProvides()

            PersistedToolchains jdksExtra = read(jdksExtraIS);
            assertEquals(2, jdks.getToolchains().size());

            merger.merge(jdks, jdksExtra, TrackableBase.USER_LEVEL);
            assertEquals(4, jdks.getToolchains().size());
            assertEquals(2, jdksExtra.getToolchains().size());
        }
        try (InputStream jdksIS = MavenToolchainMergerTest.class.getResourceAsStream("toolchains-jdks.xml");

     * @throws ToolchainManagerException if toolchain retrieval fails
     */
    @Nonnull
    default List<Toolchain> getToolchains(@Nonnull Session session, @Nonnull String type)
            throws ToolchainManagerException {
        return getToolchains(session, type, null);
    }

    /**
     * Retrieves the currently active toolchain from the build context.
     *

        if (dominant == null || recessive == null) {
            return;
        }

        recessive.setSourceLevel(recessiveSourceLevel);

        shallowMerge(dominant.getToolchains(), recessive.getToolchains(), recessiveSourceLevel);
    }

    private void shallowMerge(
            List<ToolchainModel> dominant, List<ToolchainModel> recessive, String recessiveSourceLevel) {

        Session sessionv4 = mock(Session.class);
        when(session.getSession()).thenReturn(sessionv4);
        when(sessionv4.getToolchains()).thenReturn(toolchainModels);

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

        assertEquals(0, toolchains.size());

        @Nonnull
        @Override
        public List<org.apache.maven.api.Toolchain> getToolchains(
                @Nonnull Session session, @Nonnull String type, @Nullable Map<String, String> requirements)
                throws ToolchainManagerException {
            return getDelegate().getToolchains(session, type, requirements);
        }

        @Nonnull
        @Override

    public Settings getSettings() {
        return getMavenSession().getSettings().getDelegate();
    }

    @Nonnull
    @Override
    public Collection<ToolchainModel> getToolchains() {
        return getMavenSession().getRequest().getToolchains().values().stream()
                .flatMap(Collection::stream)
                .map(org.apache.maven.toolchain.model.ToolchainModel::getDelegate)
                .toList();
    }

            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;
    }

     * @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);

     * @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