private ProjectBuildingRequest toRequest(ProjectBuilderConfiguration configuration) {
        DefaultProjectBuildingRequest request = new DefaultProjectBuildingRequest();

        request.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MAVEN_2_0);
        request.setResolveDependencies(false);

        request.setLocalRepository(configuration.getLocalRepository());

    }

    @Override
    public int getValidationLevel() {
        return request.getValidationLevel();
    }

    @Override
    public FilterModelBuildingRequest setValidationLevel(int validationLevel) {
        request.setValidationLevel(validationLevel);

        return this;
    }

    @Override
    public boolean isProcessPlugins() {
        return request.isProcessPlugins();
    }

    @Override

     */
    public DefaultModelBuildingRequest(ModelBuildingRequest request) {
        setPomPath(request.getPomPath());
        setModelSource(request.getModelSource());
        setValidationLevel(request.getValidationLevel());
        setProcessPlugins(request.isProcessPlugins());
        setTwoPhaseBuilding(request.isTwoPhaseBuilding());
        setLocationTracking(request.isLocationTracking());

    public ModelValidationResult validate(Model model) {
        ModelValidationResult result = new ModelValidationResult();

        ModelBuildingRequest request =
                new DefaultModelBuildingRequest().setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MAVEN_2_0);

        SimpleModelProblemCollector problems = new SimpleModelProblemCollector(result);

        modelValidator.validateEffectiveModel(model, request, problems);

        Model out = interpolator.interpolateModel(
                model,
                (Path) null,
                createModelBuildingRequest(context).setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MAVEN_4_0),
                collector);

        assertCollectorState(0, 0, 0, collector);
        assertEquals(interpolatedName, out.getName());
    }

    @Test

        return validateRaw(pom, UnaryOperator.identity());
    }

    private SimpleProblemCollector validateEffective(String pom, int level) throws Exception {
        return validateEffective(pom, mbr -> mbr.setValidationLevel(level));
    }

    private SimpleProblemCollector validateEffective(String pom, UnaryOperator<ModelBuildingRequest> requestConfigurer)
            throws Exception {
        Model model = read(pom);

                    return model;
                }
            }

            try {
                ModelBuildingRequest modelRequest = new DefaultModelBuildingRequest();
                modelRequest.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL);
                modelRequest.setProcessPlugins(false);
                modelRequest.setTwoPhaseBuilding(false);

            Path pomFile, int validationLevel, boolean locationTracking, TransformerContext context) {
        final ModelBuildingRequest request = new DefaultModelBuildingRequest()
                .setValidationLevel(validationLevel)
                .setLocationTracking(locationTracking)
                .setModelSource(new FileModelSource(pomFile));

                    configuration.setLocalRepository(repositoryRequest.getLocalRepository());
                    configuration.setRemoteRepositories(repositoryRequest.getRemoteRepositories());
                    configuration.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL);
                    configuration.setProcessPlugins(false);
                    configuration.setRepositoryMerging(ProjectBuildingRequest.RepositoryMerging.REQUEST_DOMINANT);

     *
     * @param validationLevel The level of validation to perform on processed models.
     * @return This request, never {@code null}.
     */
    ModelBuildingRequest setValidationLevel(int validationLevel);

    /**
     * Indicates whether plugin executions and configurations should be processed. If enabled, lifecycle-induced plugin