// Digits are greater than letters
        assertTrue(seven.compareTo(capitalJ) > 0, "expected 7 > J");
        assertTrue(capitalJ.compareTo(seven) < 0, "expected J < 1");
        assertTrue(seven.compareTo(lowerCaseC) > 0, "expected 7 > c");
        assertTrue(lowerCaseC.compareTo(seven) < 0, "expected c < 7");
    }

    @Test
    void testNonAsciiDigits() { // These should not be treated as digits.

            ComparableVersion c = new ComparableVersion(version);

            if (prev != null) {
                int compare = prev.compareTo(c);
                System.out.println(
                        "   " + prev + ' ' + ((compare == 0) ? "==" : ((compare < 0) ? "<" : ">")) + ' ' + version);
            }

            System.out.println(

                    || res2.getUpperBound() == null
                    || res1.getLowerBound().compareTo(res2.getUpperBound()) <= 0) {
                if (res1.getUpperBound() == null
                        || res2.getLowerBound() == null
                        || res1.getUpperBound().compareTo(res2.getLowerBound()) >= 0) {
                    ArtifactVersion lower;
                    ArtifactVersion upper;

    }

    @Override
    public int compareTo(Artifact a) {
        int result = groupId.compareTo(a.getGroupId());
        if (result == 0) {
            result = artifactId.compareTo(a.getArtifactId());
            if (result == 0) {
                result = type.compareTo(a.getType());
                if (result == 0) {
                    if (classifier == null) {

        assertTrue(artifact1.compareTo(artifact2) < 0);
        assertTrue(artifact2.compareTo(artifact1) > 0);

        Artifact artifact = new DefaultArtifact(
                groupId, artifactId, VersionRange.createFromVersion("5.0"), scope, type, classifier, artifactHandler);
        assertTrue(artifact.compareTo(artifact1) == 0);
        assertTrue(artifact1.compareTo(artifact) == 0);
    }

    @Test

/**
 * Resolves conflicting artifacts by always selecting the oldest declaration. Oldest is defined as the
 * declaration whose version is less according to <code>ArtifactVersion.compareTo</code>.
 *
 * @see ArtifactVersion#compareTo
 * @since 3.0
 */
@Named("oldest")
@Singleton
@Deprecated
public class OldestConflictResolver implements ConflictResolver {

    }

    private void assertVersionOlder(String left, String right) {
        assertTrue(
                newArtifactVersion(left).compareTo(newArtifactVersion(right)) < 0,
                left + " should be older than " + right);
        assertTrue(
                newArtifactVersion(right).compareTo(newArtifactVersion(left)) > 0,
                right + " should be newer than " + left);
    }

            return compareTo(artifactVersion) == 0;
        }

        return false;
    }

    @Override
    public int compareTo(ArtifactVersion otherVersion) {
        if (otherVersion instanceof DefaultArtifactVersion defaultArtifactVersion) {
            return this.comparable.compareTo(defaultArtifactVersion.comparable);
        } else {

        if (lowerBound != null) {
            int comparison = lowerBound.compareTo(version);

            if ((comparison == 0) && !lowerBoundInclusive) {
                return false;
            }
            if (comparison > 0) {
                return false;
            }
        }
        if (upperBound != null) {
            int comparison = upperBound.compareTo(version);

            if ((comparison == 0) && !upperBoundInclusive) {

        }

        if (
        /* s1 != null && */ s2 == null) {
            return 1;
        }

        return s1.compareTo(s2);
    }

    // ---------------------------------------------------------------------
    @Override
    public int compareTo(MetadataGraphVertex vertex) {
        if (vertex == null || vertex.getMd() == null) {
            return 1;
        }