File file = new File(artifactBasedir, "artifact-1.0.jar");
            assertEquals("dummy", new String(Files.readAllBytes(file.toPath()), StandardCharsets.UTF_8).trim());

            artifactDeployer.deploy(file, artifact, remoteRepository(), localRepository());

            ArtifactRepository remoteRepository = remoteRepository();

                        + key.getDisplayString() + ".  Existing bindings:\n"
                        + getBoundKeys().stream()
                                .map(Key::toString)
                                .map(String::trim)
                                .sorted()
                                .distinct()
                                .collect(Collectors.joining("\n - ", " - ", "")));
            }
        };

    }

    private static class RangeValue {
        private String value;

        private boolean closed;

        RangeValue(String value, boolean closed) {
            this.value = value.trim();
            this.closed = closed;
        }

        @Override
        public String toString() {
            return value;
        }
    }

        if (basedir == null) {
            return path;
        }

        if (path == null) {
            return null;
        }

        path = path.trim();

        String base = basedir.getAbsolutePath();
        if (path.startsWith(base)) {
            path = chopLeadingFileSeparator(path.substring(base.length()));
        }

        if (path.isEmpty()) {

        String[] entries = relocationsEntries.split(",");
        try (Stream<String> lines = Arrays.stream(entries)) {
            List<Relocation> relocationList = lines.filter(
                            l -> l != null && !l.trim().isEmpty())
                    .map(l -> {
                        boolean global;
                        String splitExpr;
                        if (l.contains(">>")) {
                            global = true;

        if (excludes == null || excludes.isEmpty()) {
            return Collections.emptyList();
        }
        return Arrays.stream(excludes.split(","))
                .map(String::trim)
                .filter(s -> !s.isEmpty())
                .collect(Collectors.toList());
    }

    private ValidationReportLevel validationReportLevel(RepositorySystemSession session) {

         * {@link ReflectionValueExtractor} class.</p>
         */
        public Object getValue(String expression) {
            if (expression == null || expression.trim().isEmpty()) {
                return null;
            }

            try {
                return ReflectionValueExtractor.evaluate(expression, root, false);
            } catch (Exception e) {

    // ----------------------------------------------------------------------

    private void addPath(List<String> paths, String path) {
        if (path != null) {
            path = path.trim();
            if (!path.isEmpty()) {
                File file = new File(path);
                if (file.isAbsolute()) {
                    path = file.getAbsolutePath();
                } else if (".".equals(path)) {

            boolean isBlankVersion = descriptor.getRequiredMavenVersion() == null
                    || descriptor.getRequiredMavenVersion().trim().isEmpty();

            if (isBlankVersion) {
                // only take value from underlying POM if plugin descriptor has no explicit Maven requirement

        assertEquals(
                32 * 1024,
                pom.getValue("properties/prop2")
                        .toString()
                        .trim()
                        .replaceAll("[\n\r]", "")
                        .length());
    }

    @Test
    void testFullInterpolationOfNestedExpressions() throws Exception {