if (bound == null) {
                return null;
            }
            return new Boundary() {
                @Override
                public Version getVersion() {
                    return new DefaultVersion(versionScheme, bound.getVersion());
                }

                @Override
                public boolean isInclusive() {
                    return bound.isInclusive();
                }

     */
    @Nonnull
    Version getVersion();

    /**
     * {@return the version or meta-version of the artifact}
     * A meta-version is a version suffixed with the {@code SNAPSHOT} keyword.
     * Meta-versions are represented in a base version by their symbols (e.g., {@code SNAPSHOT}),
     * while they are replaced by, for example, the actual timestamp in the {@linkplain #getVersion() version}.
     */
    @Nonnull

            if (!metadata.getArtifactId().isEmpty()) {
                path.append(metadata.getArtifactId()).append('/');

                if (!metadata.getVersion().isEmpty()) {
                    path.append(metadata.getVersion()).append('/');
                }
            }
        }

        path.append(insertRepositoryKey(metadata.getType(), repositoryKey));

        return path.toString();

        }
        if (active && os.getArch() != null) {
            active = determineArchMatch(os.getArch(), actualOsArch);
        }
        if (active && os.getVersion() != null) {
            active = determineVersionMatch(os.getVersion(), actualOsVersion);
        }

        return active;
    }

    @Override

        }
        if (result && os.getVersion() != null) {
            result = determineVersionMatch(os.getVersion());
        }
        return result;
    }

    private boolean ensureAtLeastOneNonNull(ActivationOS os) {
        return os.getArch() != null || os.getFamily() != null || os.getName() != null || os.getVersion() != null;
    }

    private boolean determineVersionMatch(String version) {

        assertNull(artifact.getVersion());
        assertNull(artifact.getBaseVersion());
    }

    @Test
    void testMNG7780() throws Exception {
        VersionRange vr = VersionRange.createFromVersionSpec("[1.0,2.0)");
        artifact = new DefaultArtifact(groupId, artifactId, vr, scope, type, null, artifactHandler);
        assertNull(artifact.getVersion());
        assertNull(artifact.getBaseVersion());

                .version("1.0")
                .build();

        assertNotNull(this.newModelResolver().resolveModel(parent, new AtomicReference<>()));
        assertEquals("1.0", parent.getVersion());
    }

    @Test
    void testResolveParentSuccessfullyResolvesExistingParentUsingHighestVersion() throws Exception {
        final Parent parent = Parent.newBuilder()
                .groupId("ut.simple")

                boolean exists = installed.stream().map(this::getArtifactFromMap)
                        .anyMatch(a -> a.getName().equals(target.getName()) && a.getVersion().equals(target.getVersion()));
                if (!exists) {
                    ThreadUtil.sleep(500);
                    continue;
                }

        clone.setRelease(artifact.isRelease());
        clone.setResolvedVersion(artifact.getVersion());
        clone.setResolved(artifact.isResolved());
        clone.setFile(artifact.getFile());

        clone.setAvailableVersions(copyList(artifact.getAvailableVersions()));
        if (artifact.getVersion() != null) {
            clone.setBaseVersion(artifact.getBaseVersion());
        }

        // TODO Should this be changed for MNG-6754 too?
        versioning.updateTimestamp();
        versioning.addVersion(artifact.getVersion());

        if (artifact.isRelease()) {
            versioning.setRelease(artifact.getVersion());
        }

        return new ArtifactRepositoryMetadata(artifact, versioning);
    }

    @Override