This is an automated email from the ASF dual-hosted git repository.

afs pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/jena.git


The following commit(s) were added to refs/heads/main by this push:
     new 9ca22498cc GH-4365: Use codepoint compare systematically; handle 
rdf:dirLangStr
9ca22498cc is described below

commit 9ca22498ccc470818399bafc4f7266a7731b4cf3
Author: Andy Seaborne <[email protected]>
AuthorDate: Sat Oct 31 14:11:58 2026 +0000

    GH-4365: Use codepoint compare systematically; handle rdf:dirLangStr
---
 .../org/apache/jena/sparql/expr/NVCompare.java     |  33 +++---
 .../org/apache/jena/sparql/expr/NodeValue.java     |   2 +-
 .../jena/sparql/expr/nodevalue/XSDFuncOp.java      |  67 +++--------
 .../java/org/apache/jena/sparql/util/NodeCmp.java  | 131 +++++++++++++++------
 .../org/apache/jena/sparql/util/NodeUtils.java     |   4 +-
 .../jena/sparql/expr/TestCompareLangString.java    |  37 ++++++
 .../org/apache/jena/sparql/expr/TestOrdering.java  |  80 +++++++++----
 .../java/org/apache/jena/atlas/lib/StrUtils.java   |  51 ++++++++
 .../org/apache/jena/atlas/lib/TestStrUtils.java    |  45 +++++++
 9 files changed, 316 insertions(+), 134 deletions(-)

diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/NVCompare.java 
b/jena-arq/src/main/java/org/apache/jena/sparql/expr/NVCompare.java
index 6f6a6af3c9..6b7dd38a98 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/NVCompare.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/NVCompare.java
@@ -307,18 +307,31 @@ class NVCompare {
                     // Different lang tags - sorting
                     return x;
                 }
-
                 // same lang tag (case insensitive)
+                // Check BaseDirection. If different,
+                if ( ! Objects.equals(node1.getLiteralBaseDirection(), 
node2.getLiteralBaseDirection()) ) {
+                    if ( !sortOrderingCompare )
+                        raise(new ExprNotComparableException("Can't compare 
(different base direction) " + nv1 + " and " + nv2));
+                    if ( node1.getLiteralBaseDirection() == null )
+                         return CMP_LESS;
+                    if ( node2.getLiteralBaseDirection() == null )
+                            return CMP_GREATER;
+                    // ASCII compare.
+                    return 
StrUtils.strCompare(node1.getLiteralBaseDirection().direction(),
+                                               
node2.getLiteralBaseDirection().direction());
+                }
+                // same lang tag (case insensitive) and same base direction.
                 x = XSDFuncOp.compareString(nv1, nv2);
                 if ( x != CMP_EQUAL )
                     return x;
                 // Same lexical forms, same lang tag by value
                 // Try to split by syntactic lang tags.
+                // Language tags are ASCII.
                 x = StrUtils.strCompare(node1.getLiteralLanguage(), 
node2.getLiteralLanguage());
                 // Maybe they are the same after all!
                 // Should be node.equals by now.
                 if ( x == CMP_EQUAL  && ! NodeFunctions.sameTerm(node1, node2) 
)
-                    throw new ARQInternalErrorException("Looks like the same 
(lang tags) but not node equals");
+                    throw new ARQInternalErrorException("Looks like the same 
term but not node equals");
                 return x;
             }
 
@@ -427,7 +440,8 @@ class NVCompare {
      */
     private static int compareRepresentations(String string1, String string2, 
boolean sortOrderingCompare) {
         if ( sortOrderingCompare )
-            return strcompare(string1, string2);
+            return XSDFuncOp.compareString(string1, string2);
+        // Not for sorting.
         if ( string1.equals(string2) )
             return Expr.CMP_EQUAL;
         return Expr.CMP_UNEQUAL;
@@ -524,17 +538,4 @@ class NVCompare {
         else
             return compareByValue(nv1, nv2);
     }
-
-    private static int strcompare(String string1, String string2) {
-        // StrUtils.strCompare(string1, string2);
-        return result(string1.compareTo(string2));
-    }
-
-    /**
-     * Return of comparision - always -1,0 or +1
-     */
-    private static int result(int x) {
-        return ( x == 0 ) ? Expr.CMP_EQUAL
-            : ( ( x > 0 ) ? Expr.CMP_GREATER : Expr.CMP_LESS );
-    }
 }
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/NodeValue.java 
b/jena-arq/src/main/java/org/apache/jena/sparql/expr/NodeValue.java
index 94a58f251c..cea75e1d5a 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/NodeValue.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/NodeValue.java
@@ -497,7 +497,7 @@ public abstract class NodeValue extends ExprNode
 
     public boolean isBoolean()      { return false; }
     public boolean isString()       { return false; }
-    public boolean isLangString()   { return false; }  // xsd:rdfLangString 
and rdf:dirLangString
+    public boolean isLangString()   { return false; }  // rdf:langString and 
rdf:dirLangString
     public boolean isSortKey()      { return false; }
 
     public boolean isNumber()       { return false; }
diff --git 
a/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/XSDFuncOp.java 
b/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/XSDFuncOp.java
index fb06d8a5ce..11517e3009 100644
--- 
a/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/XSDFuncOp.java
+++ 
b/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/XSDFuncOp.java
@@ -44,6 +44,7 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import javax.xml.datatype.DatatypeConstants;
+import javax.xml.datatype.DatatypeConstants.Field;
 import javax.xml.datatype.Duration;
 import javax.xml.datatype.XMLGregorianCalendar;
 
@@ -1110,27 +1111,18 @@ public class XSDFuncOp
     // --------------------------------
     // Comparisons operations
     // Do not confuse with sameValueAs/notSamevalueAs
-
-    private static int calcReturn(int x) {
-        if ( x < 0 )
-            return Expr.CMP_LESS;
-        if ( x > 0 )
-            return Expr.CMP_GREATER;
-        return Expr.CMP_EQUAL;
-    }
-
     public static int compareNumeric(NodeValue nv1, NodeValue nv2) {
         NumericType opType = classifyNumeric("compareNumeric", nv1, nv2);
 
         switch (opType) {
             case OP_INTEGER :
-                return 
calcReturn(nv1.getInteger().compareTo(nv2.getInteger()));
+                return nv1.getInteger().compareTo(nv2.getInteger());
             case OP_DECIMAL :
-                return 
calcReturn(nv1.getDecimal().compareTo(nv2.getDecimal()));
+                return nv1.getDecimal().compareTo(nv2.getDecimal());
             case OP_FLOAT :
-                return calcReturn(Float.compare(nv1.getFloat(), 
nv2.getFloat()));
+                return Float.compare(nv1.getFloat(), nv2.getFloat());
             case OP_DOUBLE :
-                return calcReturn(Double.compare(nv1.getDouble(), 
nv2.getDouble()));
+                return Double.compare(nv1.getDouble(), nv2.getDouble());
             default :
                 throw new ARQInternalErrorException("Unrecognized numeric 
operation : (" + nv1 + " ," + nv2 + ")");
         }
@@ -1151,45 +1143,16 @@ public class XSDFuncOp
     public static int compareString(NodeValue nv1, NodeValue nv2) {
         String s1 = nv1.getString();
         String s2 = nv2.getString();
-        int len1 = s1.length();
-        int len2 = s2.length();
-        int probeLimit = Math.min(Math.min(len1, len2), 4);
-        // Most unequal strings differ near the start. Decode only at that 
difference.
-        for ( int i = 0; i < probeLimit; i++ ) {
-            char c1 = s1.charAt(i);
-            char c2 = s2.charAt(i);
-            if ( c1 != c2 ) {
-                int j = i;
-                // A shared high surrogate may combine with only one of these 
chars.
-                if ( i > 0 && Character.isHighSurrogate(s1.charAt(i - 1))
-                     && (Character.isLowSurrogate(c1) || 
Character.isLowSurrogate(c2)) )
-                    j = i - 1;
-                return calcReturn(Integer.compare(s1.codePointAt(j), 
s2.codePointAt(j)));
-            }
-        }
-        if ( Math.min(len1, len2) <= probeLimit )
-            return calcReturn(Integer.compare(len1, len2));
-
-        int utf16Order = s1.compareTo(s2);
-        // Without surrogate pairs, UTF-16 order is code point order. String 
comparison
-        // can handle a long common prefix more efficiently than decoding each 
code point.
-        if ( utf16Order == 0 || (s1.codePointCount(0, len1) == len1
-                                && s2.codePointCount(0, len2) == len2) )
-            return calcReturn(utf16Order);
-
-        int i1 = 0;
-        int i2 = 0;
-        // SPARQL uses Unicode code point order, not UTF-16 code unit order.
-        while ( i1 < s1.length() && i2 < s2.length() ) {
-            int cp1 = s1.codePointAt(i1);
-            int cp2 = s2.codePointAt(i2);
-            if ( cp1 != cp2 )
-                return calcReturn(Integer.compare(cp1, cp2));
-            i1 += Character.charCount(cp1);
-            i2 += Character.charCount(cp2);
-        }
-        // A remaining suffix sorts after its matching prefix.
-        return calcReturn(Integer.compare(s1.length() - i1, s2.length() - i2));
+        return compareString(s1, s2);
+    }
+
+    /*
+     * Do a codepoint compare of two strings.
+     * This is not a duplicate of {@code String.compateTo} which compares
+     * UTF-16 code units (i.e. surrogates as characters).
+     */
+    public static int compareString(String s1, String s2) {
+        return StrUtils.strCompareCodePoint(s1, s2);
     }
 
     // --------------------------------
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/util/NodeCmp.java 
b/jena-arq/src/main/java/org/apache/jena/sparql/util/NodeCmp.java
index b609e824f0..a5d55d0ba5 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/util/NodeCmp.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/util/NodeCmp.java
@@ -56,7 +56,7 @@ public class NodeCmp {
         //-- Variables
         if ( node1.isVariable() ) {
             if ( node2.isVariable() ) {
-                return StrUtils.strCompare(node1.getName(), node2.getName());
+                return StrUtils.strCompareCodePoint(node1.getName(), 
node2.getName());
             }
             // Variables before anything else
             return Expr.CMP_LESS;
@@ -72,7 +72,7 @@ public class NodeCmp {
             if ( node2.isBlank() ) {
                 String s1 = node1.getBlankNodeLabel();
                 String s2 = node2.getBlankNodeLabel();
-                return StrUtils.strCompare(s1, s2);
+                return StrUtils.strCompareCodePoint(s1, s2);
             }
             // bNodes before anything but variables
             return Expr.CMP_LESS;
@@ -89,7 +89,7 @@ public class NodeCmp {
             if ( node2.isURI() ) {
                 String s1 = node1.getURI();
                 String s2 = node2.getURI();
-                return StrUtils.strCompare(s1, s2);
+                return StrUtils.strCompareCodePoint(s1, s2);
             }
             return Expr.CMP_LESS;
         }
@@ -156,13 +156,13 @@ public class NodeCmp {
             return Expr.CMP_EQUAL;
 
         // ** Rewrite as a classifier.??
-        // simple < lang < datatype
+        // simple < lang < langdir < datatype
 
         // Both simple? (xsd:string in RDF 1.1)
         if ( isSimpleString(node1) && isSimpleString(node2) ) {
             String lex1 = node1.getLiteralLexicalForm();
             String lex2 = node2.getLiteralLexicalForm();
-            return StrUtils.strCompare(lex1, lex2);
+            return StrUtils.strCompareCodePoint(lex1, lex2);
         }
 
         // Any simple string?
@@ -171,39 +171,24 @@ public class NodeCmp {
         if ( isSimpleString(node2) )
             return Expr.CMP_GREATER;
 
-        // No simple string from here on.
-
+        // No simple strings from here on.
         {
-            int x = compareRDFLangTerms(node1, node2);
-            if ( x != Expr.CMP_INDETERMINATE )
-                return x;
+            int x1 = compareRDFDirLangTerms(node1, node2);
+            if ( x1 != Expr.CMP_INDETERMINATE )
+                return x1;
+            // No simple string, no dirlang from here on.
+            int x2 = compareRDFLangOnlyTerms(node1, node2);
+            if ( x2 != Expr.CMP_INDETERMINATE )
+                return x2;
         }
 
-        // No simple strings, no lang strings.
-        // Compare by datatype then lexical form.
-
-        // Switch for old world (Jena 4.5.0 and before)
-        // Affects ordering for datatypes (not simple or lang strings).
-        // false - old world.
-        final boolean byDatatype = false;
-        if ( byDatatype ) {
-            String dt1 = node1.getLiteralDatatypeURI();
-            String dt2 = node2.getLiteralDatatypeURI();
-
-            int x = StrUtils.strCompare(dt1, dt2);
-            if ( x != Expr.CMP_EQUAL )
-                return x;
-            // Same datatype
-            String lex1 = node1.getLiteralLexicalForm();
-            String lex2 = node2.getLiteralLexicalForm();
-            return StrUtils.strCompare(lex1, lex2);
-        }
+        // No simple strings, no lang strings, no langdir strings
 
-        // Old Jena 4.5.0 : lexical form before datatype.
+        // Compare lexical form before datatype (the long-time choice).
         String lex1 = node1.getLiteralLexicalForm();
         String lex2 = node2.getLiteralLexicalForm();
 
-        int x = StrUtils.strCompare(lex1, lex2);
+        int x = StrUtils.strCompareCodePoint(lex1, lex2);
         if ( x != Expr.CMP_EQUAL )
             return x;
 
@@ -211,39 +196,111 @@ public class NodeCmp {
         String dt1 = node1.getLiteralDatatypeURI();
         String dt2 = node2.getLiteralDatatypeURI();
         // Two datatypes.
-        return StrUtils.strCompare(dt1, dt2);
+        return StrUtils.strCompareCodePoint(dt1, dt2);
+
+//        // Compare by datatype then lexical form.
+//        String dt1 = node1.getLiteralDatatypeURI();
+//        String dt2 = node2.getLiteralDatatypeURI();
+//
+//        int x = StrUtils.strCompareCodePoint(dt1, dt2);
+//        if ( x != Expr.CMP_EQUAL )
+//            return x;
+//        // Same datatype
+//        String lex1 = node1.getLiteralLexicalForm();
+//        String lex2 = node2.getLiteralLexicalForm();
+//        return StrUtils.strCompareCodePoint(lex1, lex2);
     }
 
-    /** May return {@link Expr#CMP_INDETERMINATE} */
-    private static int compareRDFLangTerms(Node node1, Node node2) {
+    /** Compare by language direction only - may return {@link 
Expr#CMP_INDETERMINATE} */
+    private static int compareRDFDirLangTerms(Node node1, Node node2) {
+        if ( isDirLangString(node1) && isDirLangString(node2) ) {
+            String dir1 = node1.getLiteralBaseDirection().direction();
+            String dir2 = node2.getLiteralBaseDirection().direction();
+            int x1 = StrUtils.strCompareIgnoreCase(dir1, dir2);
+            if ( x1 != Expr.CMP_EQUAL )
+                return x1;
+            // Same direction.
+            return compareByLangThenLex(node1, node2);
+        }
+
+        // Any language direction?
+        // lang < dirlang < datatype
+
+        if ( isDirLangString(node1) ) {
+            if ( isLangString(node2) )
+                // dirLang > lang
+                return Expr.CMP_GREATER;
+            // dirLAng < lang or datatype.
+            return Expr.CMP_LESS;
+        }
+        if ( isDirLangString(node2) ) {
+            if ( isLangString(node1) )
+                // lang < dirLang
+                return Expr.CMP_LESS;
+            // datatype > dirLang
+            return Expr.CMP_GREATER;
+        }
+        return Expr.CMP_INDETERMINATE;
+    }
+
+    /**
+     * Compare by language only - may return {@link Expr#CMP_INDETERMINATE}.
+     * DirLang checking has been done.
+     */
+    private static int compareRDFLangOnlyTerms(Node node1, Node node2) {
         if ( isLangString(node1) && isLangString(node2) ) {
             String lang1 = node1.getLiteralLanguage();
             String lang2 = node2.getLiteralLanguage();
             int x = StrUtils.strCompareIgnoreCase(lang1, lang2);
             if ( x != Expr.CMP_EQUAL )
                 return x;
+
             // Two langs, same lang tag => lexical form.
             String lex1 = node1.getLiteralLexicalForm();
             String lex2 = node2.getLiteralLexicalForm();
-            x = StrUtils.strCompare(lex1, lex2);
+            x = StrUtils.strCompareCodePoint(lex1, lex2);
             if ( x != Expr.CMP_EQUAL )
                 return x;
 
             // Same (case insensitive) lang, same lexical for - can be split 
them?
+            // ASCII comparision.
             x = StrUtils.strCompare(lang1, lang2);
             if ( x != Expr.CMP_EQUAL )
                 return x;
             throw new ARQInternalErrorException("Same lang tag (inc case, same 
lexical form but not node.equals");
         }
-
         // Any lang string?
         if ( isLangString(node1) )
-            // lang < datatype
+            // lang < dirlang < datatype
             return Expr.CMP_LESS;
 
         if ( isLangString(node2) )
             return Expr.CMP_GREATER;
 
+
+
+
+
         return Expr.CMP_INDETERMINATE;
     }
+
+
+    // Compare two nodes that are known to have a language tag and are the 
same kind (both rdf:langsString or both rdf:dirLangString)
+    // Do not mix rdf:langsString and rdf:dirLangString
+    private static int compareByLangThenLex(Node node1, Node node2) {
+        String lang1 = node1.getLiteralLanguage();
+        String lang2 = node2.getLiteralLanguage();
+        int x = StrUtils.strCompareIgnoreCase(lang1, lang2);
+        if ( x != Expr.CMP_EQUAL )
+            return x;
+        // Two langs, same lang tag => lexical form.
+        String lex1 = node1.getLiteralLexicalForm();
+        String lex2 = node2.getLiteralLexicalForm();
+        x = StrUtils.strCompareCodePoint(lex1, lex2);
+        if ( x != Expr.CMP_EQUAL )
+            return x;
+        // Same except by language case (which should have been canicalized)
+        x = StrUtils.strCompare(lang1, lang2);
+        return x;
+    }
 }
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/util/NodeUtils.java 
b/jena-arq/src/main/java/org/apache/jena/sparql/util/NodeUtils.java
index 74f5b9c40c..24c3796c7a 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/util/NodeUtils.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/util/NodeUtils.java
@@ -206,8 +206,8 @@ public class NodeUtils
     public static boolean isLangString(Node n) { return Util.isLangString(n); }
 
     /**
-     * A Node is a language string if it has a language tag.
-     * (RDF 1.0 and RDF 1.1)
+     * A Node is a dirLangString if it has a language tag and a base direction
+     * (RDF 1.2)
      */
     public static boolean isDirLangString(Node n) { return 
Util.isDirLangString(n); }
 
diff --git 
a/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestCompareLangString.java 
b/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestCompareLangString.java
index 6c4cd603b2..e311112a28 100644
--- 
a/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestCompareLangString.java
+++ 
b/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestCompareLangString.java
@@ -20,6 +20,7 @@
 
 package org.apache.jena.sparql.expr;
 
+import static org.apache.jena.graph.TextDirection.*;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -29,11 +30,15 @@ import java.util.List;
 
 import org.junit.jupiter.api.Test;
 
+import org.apache.jena.graph.TextDirection;
 import org.apache.jena.query.DatasetFactory;
 import org.apache.jena.query.QueryExecution;
 import org.apache.jena.query.QueryExecutionFactory;
 import org.apache.jena.query.ResultSet;
 
+/**
+ * Codepoint comparision: rdf:langString and rdf:dirLangString
+ */
 public class TestCompareLangString {
     private static final String BMP = Character.toString(0xFFE0);
     private static final String ASTRAL = Character.toString(0x1D11E);
@@ -42,6 +47,11 @@ public class TestCompareLangString {
         return "'" + value + "'@" + tag;
     }
 
+    private static String literal(String value, String tag, TextDirection 
textDir) {
+        return "'" + value + "'@" + tag + "--" + textDir.direction();
+    }
+
+
     private static boolean expression(String expression) {
         String query = "PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> SELECT 
(" + expression + " AS ?result) WHERE {}";
         try (QueryExecution exec = QueryExecutionFactory.create(query, 
DatasetFactory.empty())) {
@@ -57,6 +67,22 @@ public class TestCompareLangString {
         assertTrue(expression(literal(ASTRAL, "en") + " > " + literal(BMP, 
"en")));
     }
 
+    @Test public void sameLangDirLessThan() {
+        assertTrue(expression(literal(BMP, "en", LTR) + " < " + 
literal(ASTRAL, "en", LTR)));
+    }
+
+    @Test public void sameLangDirGreaterThan() {
+        assertTrue(expression(literal(ASTRAL, "en", LTR) + " > " + 
literal(BMP, "en", LTR)));
+    }
+
+    @Test public void differentLangDir() {
+        assertTrue(expression(literal("AAAA", "en", LTR) + " != " + 
literal("AAAA", "en", RTL)));
+    }
+
+    @Test public void differentLangSameLangDir() {
+        assertTrue(expression(literal("AAAA", "fr", LTR) + " != " + 
literal("AAAA", "en", LTR)));
+    }
+
     @Test public void sameLanguageOrderBy() {
         String query = "SELECT ?v WHERE { VALUES ?v { " + literal(ASTRAL, 
"en") + " " + literal(BMP, "en") + " } } ORDER BY ?v";
         List<String> actual = new ArrayList<>();
@@ -68,6 +94,17 @@ public class TestCompareLangString {
         assertEquals(List.of(BMP, ASTRAL), actual);
     }
 
+    @Test public void sameDirLangOrderBy() {
+        String query = "SELECT ?v WHERE { VALUES ?v { " + literal(ASTRAL, 
"en", LTR) + " " + literal(BMP, "en", LTR) + " } } ORDER BY ?v";
+        List<String> actual = new ArrayList<>();
+        try (QueryExecution exec = QueryExecutionFactory.create(query, 
DatasetFactory.empty())) {
+            ResultSet results = exec.execSelect();
+            while (results.hasNext())
+                actual.add(results.next().getLiteral("v").getLexicalForm());
+        }
+        assertEquals(List.of(BMP, ASTRAL), actual);
+    }
+
     @Test public void equalityAndMembership() {
         assertTrue(expression(literal(BMP, "en") + " = " + literal(BMP, 
"EN")));
         assertTrue(expression(literal(BMP, "en") + " != " + literal(ASTRAL, 
"en")));
diff --git 
a/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestOrdering.java 
b/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestOrdering.java
index 997f702dd4..1510552b27 100644
--- a/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestOrdering.java
+++ b/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestOrdering.java
@@ -21,6 +21,7 @@
 
 package org.apache.jena.sparql.expr;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Test;
@@ -28,39 +29,47 @@ import org.junit.jupiter.api.Test;
 import org.apache.jena.datatypes.xsd.XSDDatatype;
 import org.apache.jena.graph.Node;
 import org.apache.jena.graph.NodeFactory;
+import org.apache.jena.graph.TextDirection;
 import org.apache.jena.sparql.sse.SSE;
+//import org.apache.jena.sparql.util.NodeCmp;
 import org.apache.jena.sparql.util.NodeCmp;
 
 /**
  * See also {@link TestComparison} and {@link TestSortOrdering}.
  */
 public class TestOrdering {
-    private NodeValue nvInt2 = NodeValue.makeNodeInteger(2);
-    private NodeValue nvInt3 = NodeValue.makeNodeInteger("3");
-    private NodeValue nvInt03 = NodeValue.makeNodeInteger("03");
-    private NodeValue nvStr3 = NodeValue.makeNodeString("3");
-    private NodeValue nvStr03 = NodeValue.makeNodeString("03");
-
-    private NodeValue nvInt9 = NodeValue.makeNodeInteger(9);
-    private NodeValue nvPosInt9 = NodeValue.makeNode("9", 
XSDDatatype.XSDpositiveInteger);
-    private NodeValue nvInt10 = NodeValue.makeNodeInteger(10);
-    private NodeValue nvDouble9 = NodeValue.makeNodeDouble(9.0);
-    private NodeValue nvFloat8 = NodeValue.makeNode("8.0", 
XSDDatatype.XSDfloat);
-
-    private NodeValue nvByte10 = NodeValue.makeNode("10", XSDDatatype.XSDbyte);
-
-    private Node nInt2 = nvInt2.getNode();
-    private Node nInt3 = nvInt3.getNode();
-    private Node nInt03 = nvInt03.getNode();
-    private Node nStr3 = nvStr3.getNode();
-    private Node nStr03 = nvStr03.getNode();
-
-    private Node nInt9 = nvInt9.getNode();
-    private Node nPosInt9 = nvPosInt9.getNode();
-    private Node nInt10 = nvInt10.getNode();
-    private Node nDouble9 = nvDouble9.getNode();
-    private Node nFloat8 = nvFloat8.getNode();
-    private Node nByte10 = nvByte10.getNode();
+    private static NodeValue nvInt2 = NodeValue.makeNodeInteger(2);
+    private static NodeValue nvInt3 = NodeValue.makeNodeInteger("3");
+    private static NodeValue nvInt03 = NodeValue.makeNodeInteger("03");
+    private static NodeValue nvStr3 = NodeValue.makeNodeString("3");
+    private static NodeValue nvStr03 = NodeValue.makeNodeString("03");
+
+    private static NodeValue nvInt9 = NodeValue.makeNodeInteger(9);
+    private static NodeValue nvPosInt9 = NodeValue.makeNode("9", 
XSDDatatype.XSDpositiveInteger);
+    private static NodeValue nvInt10 = NodeValue.makeNodeInteger(10);
+    private static NodeValue nvDouble9 = NodeValue.makeNodeDouble(9.0);
+    private static NodeValue nvFloat8 = NodeValue.makeNode("8.0", 
XSDDatatype.XSDfloat);
+
+    private static NodeValue nvByte10 = NodeValue.makeNode("10", 
XSDDatatype.XSDbyte);
+
+    private static Node nInt2 = nvInt2.getNode();
+    private static Node nInt3 = nvInt3.getNode();
+    private static Node nInt03 = nvInt03.getNode();
+    private static Node nStr3 = nvStr3.getNode();
+    private static Node nStr03 = nvStr03.getNode();
+
+    private static Node nInt9 = nvInt9.getNode();
+    private static Node nPosInt9 = nvPosInt9.getNode();
+    private static Node nInt10 = nvInt10.getNode();
+    private static Node nDouble9 = nvDouble9.getNode();
+    private static Node nFloat8 = nvFloat8.getNode();
+    private static Node nByte10 = nvByte10.getNode();
+
+    private static Node nStrDirLang = NodeFactory.createLiteralDirLang("ABCD", 
"en", TextDirection.LTR);
+    private static Node nStrLang    = NodeFactory.createLiteralLang("ABCD", 
"en");
+    private static Node nStr        = NodeFactory.createLiteralString("ABCD");
+
+    // Syntax and value tests
 
     @Test
     public void testComp_2_3() {
@@ -88,6 +97,25 @@ public class TestOrdering {
         assertTrue(Expr.CMP_GREATER == y, ()->"03 should be syntactic-less 
than to \"3\"");
     }
 
+    // Syntax: string, lang  and dirlang
+    @Test
+    public void testComp_string_types_01() {
+        int x = NodeCmp.compareRDFTerms(nStr, nStrDirLang);
+        assertEquals(Expr.CMP_LESS, x, "string is not less than 
rdf:strDirLang");
+    }
+
+    @Test
+    public void testComp_string_types_02() {
+        int x = NodeCmp.compareRDFTerms(nStr, nStrLang);
+        assertEquals(Expr.CMP_LESS, x, "string is not less than rdf:strLang");
+    }
+
+    @Test
+    public void testComp_string_types_03() {
+        int x = NodeCmp.compareRDFTerms(nStrLang, nStrDirLang);
+        assertEquals(Expr.CMP_LESS, x, "rdf:strLang is not less than 
rdf:strDirLang");
+    }
+
     // Compare things of different types.
     @Test
     public void testComp_int_double_1() {
diff --git a/jena-base/src/main/java/org/apache/jena/atlas/lib/StrUtils.java 
b/jena-base/src/main/java/org/apache/jena/atlas/lib/StrUtils.java
index f7706bf152..dab1bfe933 100644
--- a/jena-base/src/main/java/org/apache/jena/atlas/lib/StrUtils.java
+++ b/jena-base/src/main/java/org/apache/jena/atlas/lib/StrUtils.java
@@ -61,6 +61,10 @@ public class StrUtils //extends StringUtils
     public static final int CMP_UNEQUAL  = -9 ;
     public static final int CMP_INDETERMINATE  = 2 ;
 
+    /**
+     * Compare using Java String.compareTo, which is code unit/UTF16-sensitive
+     * See {@link #strCompareCodePoint(String, String)} for a code point 
comparision.
+     */
     public static int strCompare(String s1, String s2) {
         // Value is the difference of the first differing chars
         int x = s1.compareTo(s2) ;
@@ -70,6 +74,53 @@ public class StrUtils //extends StringUtils
         throw new InternalErrorException("String comparison failure") ;
     }
 
+    /**
+     * Compare string by codepoint.
+     * This is in contrast to {@link #strCompare(String, String)} which uses 
{@code Java String.compareTo}, which is code unit/UTF16-sensitive
+     * @see #strCompare(String, String)
+     */
+    public static int strCompareCodePoint(String s1, String s2) {
+        int len1 = s1.length();
+        int len2 = s2.length();
+        int probeLimit = Math.min(Math.min(len1, len2), 4);
+        // Most unequal strings differ near the start. Decode only at that 
difference.
+        for ( int i = 0; i < probeLimit; i++ ) {
+            char c1 = s1.charAt(i);
+            char c2 = s2.charAt(i);
+            if ( c1 != c2 ) {
+                int j = i;
+                // A shared high surrogate may combine with only one of these 
chars.
+                if ( i > 0 && Character.isHighSurrogate(s1.charAt(i - 1))
+                        && (Character.isLowSurrogate(c1) || 
Character.isLowSurrogate(c2)) )
+                    j = i - 1;
+                return Integer.compare(s1.codePointAt(j), s2.codePointAt(j));
+            }
+        }
+        if ( Math.min(len1, len2) <= probeLimit )
+            return Integer.compare(len1, len2);
+
+        int utf16Order = s1.compareTo(s2);
+        // Without surrogate pairs, UTF-16 order is code point order. String 
comparison
+        // can handle a long common prefix more efficiently than decoding each 
code point.
+        if ( utf16Order == 0 || (s1.codePointCount(0, len1) == len1
+                && s2.codePointCount(0, len2) == len2) )
+            return Integer.signum(utf16Order);
+
+        int i1 = 0;
+        int i2 = 0;
+        // SPARQL uses Unicode code point order, not UTF-16 code unit order.
+        while ( i1 < s1.length() && i2 < s2.length() ) {
+            int cp1 = s1.codePointAt(i1);
+            int cp2 = s2.codePointAt(i2);
+            if ( cp1 != cp2 )
+                return Integer.compare(cp1, cp2);
+            i1 += Character.charCount(cp1);
+            i2 += Character.charCount(cp2);
+        }
+        // A remaining suffix sorts after its matching prefix.
+        return Integer.compare(s1.length() - i1, s2.length() - i2);
+    }
+
     public static int strCompareIgnoreCase(String s1, String s2) {
         // x is the difference of the first differing chars
         int x = s1.compareToIgnoreCase(s2) ;
diff --git 
a/jena-base/src/test/java/org/apache/jena/atlas/lib/TestStrUtils.java 
b/jena-base/src/test/java/org/apache/jena/atlas/lib/TestStrUtils.java
index 89c237884a..edcaae24de 100644
--- a/jena-base/src/test/java/org/apache/jena/atlas/lib/TestStrUtils.java
+++ b/jena-base/src/test/java/org/apache/jena/atlas/lib/TestStrUtils.java
@@ -52,6 +52,51 @@ public class TestStrUtils
         assertEquals(expected, x2);
     }
 
+    // -- Codepoints
+
+    // For codepoint comparision testing.
+    private static final String BMP = Character.toString(0xFFE0);
+    private static final String SUPPLEMENTARY = Character.toString(0x1D11E);
+    private static final String LATER_SUPPLEMENTARY = 
Character.toString(0x1F600);
+
+    private static void compareByCodepoint(String left, String right, int 
expected) {
+        assertEquals(expected, StrUtils.strCompareCodePoint(left, right));
+        assertEquals(-expected, StrUtils.strCompareCodePoint(right, left));
+    }
+
+    @Test public void codepoint_bmpBeforeSupplementary() {
+        // UTF-16 code unit order gives the opposite result to Java for this 
pair.
+        compareByCodepoint(BMP, SUPPLEMENTARY, -1);
+        compareByCodepoint(SUPPLEMENTARY, BMP, +1);
+        compareByCodepoint("a" + BMP, "a" + SUPPLEMENTARY, -1);
+        // Cross-check: Java UTF-16/surrogates
+        assertEquals(+1, Integer.signum(BMP.compareTo(SUPPLEMENTARY)));
+    }
+
+    @Test public void codepoint_supplementaryCodePoints() {
+        compareByCodepoint(SUPPLEMENTARY, LATER_SUPPLEMENTARY, -1);
+        compareByCodepoint("a" + SUPPLEMENTARY + "a", "a" + SUPPLEMENTARY + 
"b", -1);
+    }
+
+    @Test public void codepoint_equalStrings() {
+        compareByCodepoint("", "", 0);
+        compareByCodepoint(SUPPLEMENTARY + BMP, SUPPLEMENTARY + BMP, 0);
+    }
+
+    @Test public void codepoint_prefixesAndEmptyStrings() {
+        compareByCodepoint("", SUPPLEMENTARY, -1);
+        compareByCodepoint(SUPPLEMENTARY, SUPPLEMENTARY + BMP, -1);
+        compareByCodepoint("a" + SUPPLEMENTARY, "a" + SUPPLEMENTARY + "b", -1);
+    }
+
+    @Test public void codepoint_longCommonPrefix() {
+        String prefix = 
"http://example.org/resource/with/a/long/shared/prefix/";;
+        compareByCodepoint(prefix + "a", prefix + "b", -1);
+        compareByCodepoint(prefix + BMP, prefix + SUPPLEMENTARY, -1);
+    }
+
+    // -- Codepoints
+
     @Test public void enc01() { testEnc("abc") ; }
     @Test public void enc02() { testEnc("") ; }
     @Test public void enc03() { testEnc("_", "_5F" ) ; }

Reply via email to