result = result.substring(3);
                    continue;
                }
                int parent = idx - 1;
                while (parent >= 0 && result.charAt(parent) == '/') {
                    parent--;
                }
                parent = result.lastIndexOf('/', parent);
                if (parent < 0) {
                    result = result.substring(idx + 4);
                } else {

        final boolean result;
        if (test.startsWith(REGEX_PREFIX)) {
            result = actualVersion.matches(test.substring(REGEX_PREFIX.length()));
        } else {
            if (test.startsWith("!")) {
                reverse = true;
                test = test.substring(1);
            }
            result = actualVersion.equals(test);
        }

        return reverse != result;
    }

        }

        String name = property.getName();
        boolean reverseName = false;

        if (name != null && name.startsWith("!")) {
            reverseName = true;
            name = name.substring(1);
        }

        if (name == null || name.isEmpty()) {
            problems.add(
                    BuilderProblem.Severity.ERROR,
                    ModelProblem.Version.BASE,

    }

    @AfterEach
    void tearDown() throws Exception {
        validator = null;
    }

    private void assertContains(String msg, String substring) {
        assertTrue(msg.contains(substring), "\"" + substring + "\" was not found in: " + msg);
    }

    @Test
    void testValidate() {
        Profile prof = Profile.newBuilder().id("xxx").build();

                                Path basedir = projectDir.toAbsolutePath();
                                return new ObjectBasedValueSource(basedir)
                                        .getValue(expression.substring("basedir.".length()));
                            }
                            return null;
                        }
                    },
                    getProjectPrefixes(request),

        String result;
        int idx = filename.indexOf('.');
        if (idx < 0) {
            result = filename + '-' + repositoryKey;
        } else {
            result = filename.substring(0, idx) + '-' + repositoryKey + filename.substring(idx);
        }
        return result;
    }

    public LocalArtifactResult find(RepositorySystemSession session, LocalArtifactRequest request) {

        BeanConfigurationValuePreprocessor preprocessor = (value, type) -> {
            if (value != null && value.startsWith("${") && value.endsWith("}")) {
                return value.substring(2, value.length() - 1);
            }
            return value;
        };

        BeanConfigurationPathTranslator translator = path -> new File("base", path.getPath()).getAbsoluteFile();

    }

    public static boolean isJavaVersionCompatible(String requiredJdkRange, String currentJavaVersion) {
        if (requiredJdkRange.startsWith("!")) {
            return !currentJavaVersion.startsWith(requiredJdkRange.substring(1));
        } else if (isRange(requiredJdkRange)) {
            return isInRange(currentJavaVersion, getRange(requiredJdkRange));
        } else {
            return currentJavaVersion.startsWith(requiredJdkRange);

    }

    private static boolean matches(String pattern, String str) {
        if (isAny(pattern)) {
            return true;
        } else if (pattern.endsWith("*")) {
            return str.startsWith(pattern.substring(0, pattern.length() - 1));
        } else {
            return Objects.equals(pattern, str);
        }
    }

    private static Predicate<Artifact> artifactPredicate(Artifact artifact) {

            List<String> paths = map.keySet().stream()
                    .map(Object::toString)
                    .filter(s -> s.startsWith("SourceCacheKey"))
                    .map(s -> s.substring("SourceCacheKey[location=".length(), s.indexOf(", tag")))
                    .sorted()
                    .distinct()
                    .toList();
            logger.debug("ModelCache contains " + paths.size());