You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jena.apache.org by an...@apache.org on 2023/12/27 17:02:47 UTC

(jena) 10/10: Convert to Lib functions lowercase/uppercase

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

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

commit 2d8785f25d9332973f206888d252b6504a3fe9fa
Author: Andy Seaborne <an...@apache.org>
AuthorDate: Tue Dec 26 12:37:38 2023 +0000

    Convert to Lib functions lowercase/uppercase
---
 .../java/org/apache/jena/http/auth/AuthHeader.java |   4 +-
 .../java/org/apache/jena/riot/RDFLanguages.java    |   8 +-
 .../apache/jena/riot/adapters/RDFReaderRIOT.java   |  77 +--
 .../apache/jena/riot/adapters/RDFWriterRIOT.java   |   5 +-
 .../process/normalize/StreamCanonicalLangTag.java  |   4 +-
 .../apache/jena/riot/system/stream/LocatorURL.java |  35 +-
 .../java/org/apache/jena/riot/web/HttpMethod.java  |   4 +-
 .../org/apache/jena/sparql/algebra/op/OpBGP.java   |  20 +-
 .../java/org/apache/jena/sparql/expr/E_MD5.java    |   8 +-
 .../java/org/apache/jena/sparql/expr/E_SHA1.java   |  20 +-
 .../java/org/apache/jena/sparql/expr/E_SHA224.java |  20 +-
 .../java/org/apache/jena/sparql/expr/E_SHA256.java |  20 +-
 .../java/org/apache/jena/sparql/expr/E_SHA384.java |  20 +-
 .../java/org/apache/jena/sparql/expr/E_SHA512.java |  20 +-
 .../jena/sparql/expr/aggregate/AggCustom.java      |   5 +-
 .../jena/sparql/expr/aggregate/AggregatorBase.java |  59 +--
 .../sparql/function/library/FN_CollationKey.java   |  13 +-
 .../sparql/function/scripting/ScriptFunction.java  |   4 +-
 .../java/org/apache/jena/sparql/util/FmtUtils.java | 545 +++++++++------------
 .../org/apache/jena/sparql/util/RomanNumeral.java  |   4 +-
 .../java/org/apache/jena/riot/TestSysRIOT.java     |   7 +-
 .../main/java/org/apache/jena/atlas/lib/Lib.java   |   4 +-
 .../org/apache/jena/atlas/junit/AssertExtra.java   |  13 +-
 jena-cmds/src/main/java/arq/qparse.java            |  60 +--
 .../apache/jena/graph/impl/CollectionGraph.java    |  17 -
 .../java/org/apache/jena/irix/TestIRIxSyntax.java  |   6 +-
 .../java/org/apache/jena/irix/TestRFC3986.java     |   7 +-
 .../org/apache/jena/fuseki/server/Operation.java   |   5 +-
 .../apache/jena/fuseki/servlets/ActionREST.java    |   5 +-
 .../apache/jena/fuseki/servlets/ResponseOps.java   |   8 +-
 .../jena/fuseki/servlets/SPARQLQueryProcessor.java |   3 +-
 .../org/apache/jena/fuseki/mgt/ActionDatasets.java |   3 +-
 .../java/org/apache/jena/rdfpatch/PatchHeader.java |   5 +-
 .../apache/jena/rdfpatch/filelog/FilePolicy.java   |   5 +-
 .../org/apache/jena/shex/expressions/NodeKind.java |   5 +-
 .../org/apache/jena/shex/writer/WriterShExC.java   |  11 +-
 36 files changed, 498 insertions(+), 561 deletions(-)

diff --git a/jena-arq/src/main/java/org/apache/jena/http/auth/AuthHeader.java b/jena-arq/src/main/java/org/apache/jena/http/auth/AuthHeader.java
index 37a036a59c..2f4e7020a9 100644
--- a/jena-arq/src/main/java/org/apache/jena/http/auth/AuthHeader.java
+++ b/jena-arq/src/main/java/org/apache/jena/http/auth/AuthHeader.java
@@ -19,9 +19,9 @@
 package org.apache.jena.http.auth;
 
 import static org.apache.jena.atlas.lib.Chars.CH_RSLASH;
+import static org.apache.jena.atlas.lib.Lib.lowercase;
 
 import java.util.LinkedHashMap;
-import java.util.Locale;
 import java.util.Map;
 import java.util.function.IntPredicate;
 
@@ -414,7 +414,7 @@ public class AuthHeader {
                 String value = tokenOrQuotedString();
                 if ( value == null )
                     return null;
-                String lcKey = key.toLowerCase(Locale.ROOT);
+                String lcKey = lowercase(key);
                 map.put(lcKey, value);
                 skipWhitespaceComma();
             }
diff --git a/jena-arq/src/main/java/org/apache/jena/riot/RDFLanguages.java b/jena-arq/src/main/java/org/apache/jena/riot/RDFLanguages.java
index 84a99d9def..27eb0fe931 100644
--- a/jena-arq/src/main/java/org/apache/jena/riot/RDFLanguages.java
+++ b/jena-arq/src/main/java/org/apache/jena/riot/RDFLanguages.java
@@ -18,9 +18,13 @@
 
 package org.apache.jena.riot;
 
+import static org.apache.jena.atlas.lib.Lib.lowercase;
 import static org.apache.jena.riot.WebContent.*;
 
-import java.util.*;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
 
 import org.apache.jena.atlas.io.IO;
 import org.apache.jena.atlas.web.ContentType;
@@ -462,7 +466,7 @@ public class RDFLanguages
         return lang;
     }
 
-    private static String canonicalKey(String x) { return x.toLowerCase(Locale.ROOT); }
+    private static String canonicalKey(String x) { return lowercase(x); }
 
     public static ContentType guessContentType(String resourceName) {
         if ( resourceName == null )
diff --git a/jena-arq/src/main/java/org/apache/jena/riot/adapters/RDFReaderRIOT.java b/jena-arq/src/main/java/org/apache/jena/riot/adapters/RDFReaderRIOT.java
index e092c519bb..3d0179015e 100644
--- a/jena-arq/src/main/java/org/apache/jena/riot/adapters/RDFReaderRIOT.java
+++ b/jena-arq/src/main/java/org/apache/jena/riot/adapters/RDFReaderRIOT.java
@@ -16,52 +16,53 @@
  * limitations under the License.
  */
 
-package org.apache.jena.riot.adapters ;
+package org.apache.jena.riot.adapters;
 
-import java.io.InputStream ;
-import java.io.Reader ;
-import java.util.Locale ;
+import static org.apache.jena.atlas.lib.Lib.lowercase;
 
-import org.apache.jena.graph.GraphEvents ;
-import org.apache.jena.rdf.model.Model ;
-import org.apache.jena.rdf.model.RDFErrorHandler ;
-import org.apache.jena.rdf.model.RDFReaderI ;
-import org.apache.jena.rdf.model.impl.RDFDefaultErrorHandler ;
-import org.apache.jena.riot.Lang ;
-import org.apache.jena.riot.RDFDataMgr ;
-import org.apache.jena.riot.RDFLanguages ;
+import java.io.InputStream;
+import java.io.Reader;
+
+import org.apache.jena.graph.GraphEvents;
+import org.apache.jena.rdf.model.Model;
+import org.apache.jena.rdf.model.RDFErrorHandler;
+import org.apache.jena.rdf.model.RDFReaderI;
+import org.apache.jena.rdf.model.impl.RDFDefaultErrorHandler;
+import org.apache.jena.riot.Lang;
+import org.apache.jena.riot.RDFDataMgr;
+import org.apache.jena.riot.RDFLanguages;
 import org.apache.jena.riot.RDFParser;
 import org.apache.jena.riot.system.StreamRDF;
 import org.apache.jena.riot.system.StreamRDFLib;
-import org.apache.jena.sparql.util.Context ;
-import org.apache.jena.sparql.util.Symbol ;
+import org.apache.jena.sparql.util.Context;
+import org.apache.jena.sparql.util.Symbol;
 
 /** Adapter from Jena2 original style to RIOT reader. */
 public class RDFReaderRIOT implements RDFReaderI {
-    private final String      basename ;
-    protected final Lang      hintlang ;
-    protected Context         context      = new Context() ;
-    protected RDFErrorHandler errorHandler = new RDFDefaultErrorHandler() ;
+    private final String      basename;
+    protected final Lang      hintlang;
+    protected Context         context      = new Context();
+    protected RDFErrorHandler errorHandler = new RDFDefaultErrorHandler();
 
     public RDFReaderRIOT() {
-        this((Lang)null) ;
+        this((Lang)null);
     }
 
     public RDFReaderRIOT(String lang) {
-        this(lang != null ? RDFLanguages.nameToLang(lang) : null) ;
+        this(lang != null ? RDFLanguages.nameToLang(lang) : null);
     }
 
     public RDFReaderRIOT(Lang hintlang) {
-        this.hintlang = hintlang ;
+        this.hintlang = hintlang;
         this.basename = (hintlang==null)
             ? "org.apache.jena.riot.reader.generic"
-            : "org.apache.jena.riot.reader." + hintlang.getLabel().toLowerCase(Locale.ROOT) ;
+            : "org.apache.jena.riot.reader." + lowercase(hintlang.getLabel());
     }
 
     @SuppressWarnings("deprecation")
     @Override
     public void read(Model model, Reader r, String base) {
-        startRead(model) ;
+        startRead(model);
         StreamRDF dest = StreamRDFLib.graph(model.getGraph());
         RDFParser.create()
             .source(r)
@@ -69,42 +70,42 @@ public class RDFReaderRIOT implements RDFReaderI {
             .lang(hintlang)
             //.context(context)
             .parse(dest);
-        finishRead(model) ;
+        finishRead(model);
     }
 
     @Override
     public void read(Model model, InputStream r, String base) {
-        startRead(model) ;
-        RDFDataMgr.read(model, r, base, hintlang) ;
-        finishRead(model) ;
+        startRead(model);
+        RDFDataMgr.read(model, r, base, hintlang);
+        finishRead(model);
     }
 
     @Override
     public void read(Model model, String url) {
-        startRead(model) ;
-        RDFDataMgr.read(model, url, hintlang) ;
-        finishRead(model) ;
+        startRead(model);
+        RDFDataMgr.read(model, url, hintlang);
+        finishRead(model);
     }
 
     @Override
     public Object setProperty(String propName, Object propValue) {
-        Symbol sym = Symbol.create(basename + propName) ;
-        Object oldObj = context.get(sym) ;
-        return oldObj ;
+        Symbol sym = Symbol.create(basename + propName);
+        Object oldObj = context.get(sym);
+        return oldObj;
     }
 
     protected void startRead(Model model) {
-        model.notifyEvent(GraphEvents.startRead) ;
+        model.notifyEvent(GraphEvents.startRead);
     }
 
     protected void finishRead(Model model) {
-        model.notifyEvent(GraphEvents.finishRead) ;
+        model.notifyEvent(GraphEvents.finishRead);
     }
 
     @Override
     public RDFErrorHandler setErrorHandler(RDFErrorHandler errHandler) {
-        RDFErrorHandler old = errorHandler ;
-        errorHandler = errHandler ;
-        return old ;
+        RDFErrorHandler old = errorHandler;
+        errorHandler = errHandler;
+        return old;
     }
 }
diff --git a/jena-arq/src/main/java/org/apache/jena/riot/adapters/RDFWriterRIOT.java b/jena-arq/src/main/java/org/apache/jena/riot/adapters/RDFWriterRIOT.java
index afc1446369..07bc9c196c 100644
--- a/jena-arq/src/main/java/org/apache/jena/riot/adapters/RDFWriterRIOT.java
+++ b/jena-arq/src/main/java/org/apache/jena/riot/adapters/RDFWriterRIOT.java
@@ -18,10 +18,11 @@
 
 package org.apache.jena.riot.adapters;
 
+import static org.apache.jena.atlas.lib.Lib.lowercase;
+
 import java.io.OutputStream ;
 import java.io.Writer ;
 import java.util.HashMap ;
-import java.util.Locale ;
 import java.util.Map ;
 
 import org.apache.jena.rdf.model.Model ;
@@ -54,7 +55,7 @@ public class RDFWriterRIOT implements RDFWriterI
     public RDFWriterRIOT(String jenaName) {
         this.basename = (jenaName==null)
                 ? "org.apache.jena.riot.writer.generic"
-                : "org.apache.jena.riot.writer." + jenaName.toLowerCase(Locale.ROOT) ;
+                : "org.apache.jena.riot.writer." + lowercase(jenaName);
 
         this.jenaName = jenaName;
 
diff --git a/jena-arq/src/main/java/org/apache/jena/riot/process/normalize/StreamCanonicalLangTag.java b/jena-arq/src/main/java/org/apache/jena/riot/process/normalize/StreamCanonicalLangTag.java
index da6bbea784..700ad5ce5b 100644
--- a/jena-arq/src/main/java/org/apache/jena/riot/process/normalize/StreamCanonicalLangTag.java
+++ b/jena-arq/src/main/java/org/apache/jena/riot/process/normalize/StreamCanonicalLangTag.java
@@ -18,6 +18,8 @@
 
 package org.apache.jena.riot.process.normalize;
 
+import static org.apache.jena.atlas.lib.Lib.lowercase;
+
 import java.util.IllformedLocaleException;
 import java.util.Locale;
 import java.util.function.BiFunction;
@@ -72,6 +74,6 @@ public class StreamCanonicalLangTag extends StreamRDFApplyObject {
     }
 
     public static String langTagLC(Locale.Builder locBuild, String str) {
-        return str.toLowerCase(Locale.ROOT);
+        return lowercase(str);
     }
 }
diff --git a/jena-arq/src/main/java/org/apache/jena/riot/system/stream/LocatorURL.java b/jena-arq/src/main/java/org/apache/jena/riot/system/stream/LocatorURL.java
index 2ac6fb88e8..e5eb75d6c7 100644
--- a/jena-arq/src/main/java/org/apache/jena/riot/system/stream/LocatorURL.java
+++ b/jena-arq/src/main/java/org/apache/jena/riot/system/stream/LocatorURL.java
@@ -18,39 +18,38 @@
 
 package org.apache.jena.riot.system.stream;
 
-import java.util.Locale ;
-
-import org.apache.jena.atlas.web.TypedInputStream ;
+import org.apache.jena.atlas.lib.Lib;
+import org.apache.jena.atlas.web.TypedInputStream;
 import org.apache.jena.irix.IRIs;
-import org.slf4j.Logger ;
+import org.slf4j.Logger;
 
 public abstract class LocatorURL implements Locator
 {
-    private final String[] schemeNames ;
+    private final String[] schemeNames;
 
     protected LocatorURL(String[] sNames) {
-        schemeNames = sNames ;
+        schemeNames = sNames;
     }
 
-    protected abstract Logger log() ;
+    protected abstract Logger log();
 
     @Override
     public TypedInputStream open(String uri) {
         if ( ! acceptByScheme(uri) ) {
             if ( StreamManager.logAllLookups && log().isTraceEnabled() )
-                log().trace("Not found : "+uri) ;
+                log().trace("Not found : "+uri);
             return null;
         }
-        return performOpen(uri) ;
+        return performOpen(uri);
     }
 
-    protected abstract TypedInputStream performOpen(String uri) ;
+    protected abstract TypedInputStream performOpen(String uri);
 
     protected boolean acceptByScheme(String filenameOrURI) {
-        String uriSchemeName = IRIs.scheme(filenameOrURI) ;
+        String uriSchemeName = IRIs.scheme(filenameOrURI);
         if ( uriSchemeName == null )
-            return false ;
-        uriSchemeName = uriSchemeName.toLowerCase(Locale.ROOT) ;
+            return false;
+        uriSchemeName = Lib.lowercase(uriSchemeName);
         for ( String schemeName : schemeNames )
         {
             if ( uriSchemeName.equals( schemeName ) )
@@ -58,17 +57,17 @@ public abstract class LocatorURL implements Locator
                 return true;
             }
         }
-        return false ;
+        return false;
     }
 
     @Override
-    public abstract int hashCode() ;
+    public abstract int hashCode();
 
     @Override
     public boolean equals(Object obj) {
-        if (this == obj) return true ;
-        if (obj == null) return false ;
-        return getClass() == obj.getClass() ;
+        if (this == obj) return true;
+        if (obj == null) return false;
+        return getClass() == obj.getClass();
     }
 }
 
diff --git a/jena-arq/src/main/java/org/apache/jena/riot/web/HttpMethod.java b/jena-arq/src/main/java/org/apache/jena/riot/web/HttpMethod.java
index a0e57d5992..f6cc46935b 100644
--- a/jena-arq/src/main/java/org/apache/jena/riot/web/HttpMethod.java
+++ b/jena-arq/src/main/java/org/apache/jena/riot/web/HttpMethod.java
@@ -18,7 +18,7 @@
 
 package org.apache.jena.riot.web;
 
-import java.util.Locale;
+import static org.apache.jena.atlas.lib.Lib.uppercase;
 
 public enum HttpMethod {
     // METHOD_ only for transition/rename.
@@ -43,7 +43,7 @@ public enum HttpMethod {
 
     public static HttpMethod fromString(String name) {
         try {
-            return HttpMethod.valueOf(name.toUpperCase(Locale.ROOT));
+            return HttpMethod.valueOf(uppercase(name));
         } catch (IllegalArgumentException ex) {
             return null;
         }
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/algebra/op/OpBGP.java b/jena-arq/src/main/java/org/apache/jena/sparql/algebra/op/OpBGP.java
index 904ff532f9..cae395998c 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/algebra/op/OpBGP.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/algebra/op/OpBGP.java
@@ -35,26 +35,26 @@ public class OpBGP extends Op0
     }
 
     public OpBGP() { this(new BasicPattern()); }
-    
+
     public OpBGP(BasicPattern pattern)
     { this.pattern = pattern; }
-    
-    public BasicPattern getPattern()        { return pattern; } 
-    
+
+    public BasicPattern getPattern()        { return pattern; }
+
     @Override
-    public String getName()                 { return Tags.tagBGP /*.toUpperCase(Locale.ROOT)*/; }
+    public String getName()                 { return Tags.tagBGP; }
     @Override
-    public Op apply(Transform transform)    { return transform.transform(this); } 
+    public Op apply(Transform transform)    { return transform.transform(this); }
     @Override
     public void visit(OpVisitor opVisitor)  { opVisitor.visit(this); }
     @Override
     public Op0 copy()                       { return new OpBGP(pattern); }
-    
+
     @Override
     public int hashCode()
-    { 
+    {
         int calcHashCode = OpBase.HashBasicGraphPattern;
-        calcHashCode ^=  pattern.hashCode(); 
+        calcHashCode ^=  pattern.hashCode();
         return calcHashCode;
     }
 
@@ -63,7 +63,7 @@ public class OpBGP extends Op0
     {
         if ( ! ( op2 instanceof OpBGP) )
             return false;
-        
+
         OpBGP bgp2 = (OpBGP)op2;
         return pattern.equiv(bgp2.pattern, labelMap);
     }
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_MD5.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_MD5.java
index 72c3a9fbf9..2beb1ce2d3 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_MD5.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_MD5.java
@@ -18,19 +18,19 @@
 
 package org.apache.jena.sparql.expr;
 
-import java.util.Locale ;
+import static org.apache.jena.atlas.lib.Lib.uppercase;
 
 import org.apache.jena.sparql.sse.Tags ;
 
 public class E_MD5 extends ExprDigest
 {
-    private static final String symbol = Tags.tagMD5.toUpperCase(Locale.ROOT) ;
+    private static final String symbol = uppercase(Tags.tagMD5) ;
 
     public E_MD5(Expr expr)
     {
         super(expr, symbol, "MD5") ;
     }
-    
+
     @Override
-    public Expr copy(Expr expr) { return new E_MD5(expr) ; } 
+    public Expr copy(Expr expr) { return new E_MD5(expr) ; }
 }
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA1.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA1.java
index 303d92700f..bd45a8d117 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA1.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA1.java
@@ -18,19 +18,19 @@
 
 package org.apache.jena.sparql.expr;
 
-import java.util.Locale ;
+import static org.apache.jena.atlas.lib.Lib.uppercase;
 
-import org.apache.jena.sparql.sse.Tags ;
+import org.apache.jena.sparql.sse.Tags;
 
-public class E_SHA1 extends ExprDigest
-{
-    private static final String symbol = Tags.tagSHA1.toUpperCase(Locale.ROOT) ;
+public class E_SHA1 extends ExprDigest {
+    private static final String symbol = uppercase(Tags.tagSHA1);
 
-    public E_SHA1(Expr expr)
-    {
-        super(expr, symbol, "SHA-1") ;
+    public E_SHA1(Expr expr) {
+        super(expr, symbol, "SHA-1");
     }
-    
+
     @Override
-    public Expr copy(Expr expr) { return new E_SHA1(expr) ; } 
+    public Expr copy(Expr expr) {
+        return new E_SHA1(expr);
+    }
 }
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA224.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA224.java
index d4517c4937..b83c9d5f08 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA224.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA224.java
@@ -18,19 +18,19 @@
 
 package org.apache.jena.sparql.expr;
 
-import java.util.Locale ;
+import static org.apache.jena.atlas.lib.Lib.uppercase;
 
-import org.apache.jena.sparql.sse.Tags ;
+import org.apache.jena.sparql.sse.Tags;
 
-public class E_SHA224 extends ExprDigest
-{
-    private static final String symbol = Tags.tagSHA224.toUpperCase(Locale.ROOT) ;
+public class E_SHA224 extends ExprDigest {
+    private static final String symbol = uppercase(Tags.tagSHA224);
 
-    public E_SHA224(Expr expr)
-    {
-        super(expr, symbol, "SHA-224") ;
+    public E_SHA224(Expr expr) {
+        super(expr, symbol, "SHA-224");
     }
-    
+
     @Override
-    public Expr copy(Expr expr) { return new E_SHA224(expr) ; } 
+    public Expr copy(Expr expr) {
+        return new E_SHA224(expr);
+    }
 }
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA256.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA256.java
index 7b99b66cb9..7b602eb470 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA256.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA256.java
@@ -18,19 +18,19 @@
 
 package org.apache.jena.sparql.expr;
 
-import java.util.Locale ;
+import static org.apache.jena.atlas.lib.Lib.uppercase;
 
-import org.apache.jena.sparql.sse.Tags ;
+import org.apache.jena.sparql.sse.Tags;
 
-public class E_SHA256 extends ExprDigest
-{
-    private static final String symbol = Tags.tagSHA256.toUpperCase(Locale.ROOT) ;
+public class E_SHA256 extends ExprDigest {
+    private static final String symbol = uppercase(Tags.tagSHA256);
 
-    public E_SHA256(Expr expr)
-    {
-        super(expr, symbol, "SHA-256") ;
+    public E_SHA256(Expr expr) {
+        super(expr, symbol, "SHA-256");
     }
-    
+
     @Override
-    public Expr copy(Expr expr) { return new E_SHA256(expr) ; } 
+    public Expr copy(Expr expr) {
+        return new E_SHA256(expr);
+    }
 }
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA384.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA384.java
index cadade06a7..fa9aaf729b 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA384.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA384.java
@@ -18,19 +18,19 @@
 
 package org.apache.jena.sparql.expr;
 
-import java.util.Locale ;
+import static org.apache.jena.atlas.lib.Lib.uppercase;
 
-import org.apache.jena.sparql.sse.Tags ;
+import org.apache.jena.sparql.sse.Tags;
 
-public class E_SHA384 extends ExprDigest
-{
-    private static final String symbol = Tags.tagSHA384.toUpperCase(Locale.ROOT) ;
+public class E_SHA384 extends ExprDigest {
+    private static final String symbol = uppercase(Tags.tagSHA384);
 
-    public E_SHA384(Expr expr)
-    {
-        super(expr, symbol, "SHA-384") ;
+    public E_SHA384(Expr expr) {
+        super(expr, symbol, "SHA-384");
     }
-    
+
     @Override
-    public Expr copy(Expr expr) { return new E_SHA384(expr) ; } 
+    public Expr copy(Expr expr) {
+        return new E_SHA384(expr);
+    }
 }
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA512.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA512.java
index 12ba915c4e..604917932e 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA512.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/E_SHA512.java
@@ -18,19 +18,19 @@
 
 package org.apache.jena.sparql.expr;
 
-import java.util.Locale ;
+import static org.apache.jena.atlas.lib.Lib.uppercase;
 
-import org.apache.jena.sparql.sse.Tags ;
+import org.apache.jena.sparql.sse.Tags;
 
-public class E_SHA512 extends ExprDigest
-{
-    private static final String symbol = Tags.tagSHA512.toUpperCase(Locale.ROOT) ;
+public class E_SHA512 extends ExprDigest {
+    private static final String symbol = uppercase(Tags.tagSHA512);
 
-    public E_SHA512(Expr expr)
-    {
-        super(expr, symbol, "SHA-512") ;
+    public E_SHA512(Expr expr) {
+        super(expr, symbol, "SHA-512");
     }
-    
+
     @Override
-    public Expr copy(Expr expr) { return new E_SHA512(expr) ; } 
+    public Expr copy(Expr expr) {
+        return new E_SHA512(expr);
+    }
 }
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/aggregate/AggCustom.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/aggregate/AggCustom.java
index d3a4aa8e00..8485d289f0 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/aggregate/AggCustom.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/aggregate/AggCustom.java
@@ -18,7 +18,8 @@
 
 package org.apache.jena.sparql.expr.aggregate;
 
-import java.util.Locale;
+import static org.apache.jena.atlas.lib.Lib.lowercase;
+
 import java.util.Objects;
 
 import org.apache.jena.atlas.io.IndentedLineBuffer;
@@ -81,7 +82,7 @@ public class AggCustom extends AggregatorBase {
     public String toPrefixString() {
         IndentedLineBuffer x = new IndentedLineBuffer();
         x.append("(");
-        x.append(getName().toLowerCase(Locale.ROOT));
+        x.append(lowercase(getName()));
         x.append(" <");
         x.append(iri);
         x.append("> ");
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/aggregate/AggregatorBase.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/aggregate/AggregatorBase.java
index 247948dd4f..d60edb1116 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/aggregate/AggregatorBase.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/aggregate/AggregatorBase.java
@@ -18,8 +18,9 @@
 
 package org.apache.jena.sparql.expr.aggregate;
 
+import static org.apache.jena.atlas.lib.Lib.lowercase;
+
 import java.util.HashMap ;
-import java.util.Locale ;
 import java.util.Map ;
 
 import org.apache.jena.atlas.io.IndentedLineBuffer ;
@@ -34,40 +35,40 @@ import org.apache.jena.sparql.serializer.SerializationContext ;
 import org.apache.jena.sparql.sse.writers.WriterExpr ;
 import org.apache.jena.sparql.util.ExprUtils ;
 
-/** Aggregate that does everything except the per-group aggregation that is needed for each operation */  
-public abstract class AggregatorBase implements Aggregator 
+/** Aggregate that does everything except the per-group aggregation that is needed for each operation */
+public abstract class AggregatorBase implements Aggregator
 {
     // Aggregator -- handles one aggregation over one group, and is the syntax unit.
-    
+
     // AggregateFactory -- delays the creating of Aggregator so multiple mentions over the same group gives the same Aggregator
-    
+
     // Accumulator -- the per-group, per-key accumulator for the aggregate
     // queries track their aggregators so if one is used twice, the calculataion is only done once.
-    // For distinct, that means only uniquefier. 
-    
+    // For distinct, that means only uniquefier.
+
     // Built-ins: COUNT, SUM, MIN, MAX, AVG, GROUP_CONCAT, and SAMPLE
     // but COUNT(*) and COUNT(Expr) are different beasts
-    // each in DISTINCT and non-DISTINCT versions 
-    
-    protected final String name ; 
+    // each in DISTINCT and non-DISTINCT versions
+
+    protected final String name ;
     protected final boolean isDistinct ;
     protected final ExprList exprList ;
-    
+
     protected AggregatorBase(String name, boolean isDistinct, Expr expr) {
         this(name, isDistinct, new ExprList(expr)) ;
     }
-    
+
     protected AggregatorBase(String name, boolean isDistinct, ExprList exprList) {
         this.name = name ;
-        this.isDistinct = isDistinct ;  
+        this.isDistinct = isDistinct ;
         this.exprList = exprList ;
     }
-    
+
     private Map<Binding, Accumulator> buckets = new HashMap<>() ;   // Bindingkey => Accumulator
 
     @Override
     public abstract Accumulator createAccumulator() ;
-    
+
     @Override
     public abstract Node getValueEmpty() ;
 
@@ -77,14 +78,14 @@ public abstract class AggregatorBase implements Aggregator
         if ( acc == null )
             throw new ARQInternalErrorException("Null for accumulator") ;
         NodeValue nv = acc.getValue();
-        if ( nv == null ) 
+        if ( nv == null )
             return null ;
         return nv.asNode() ;
     }
-    
+
     @Override
     public String key() {  return toPrefixString() ; }
-    
+
     @Override
     public final Aggregator copyTransform(NodeTransform transform)
     {
@@ -93,7 +94,7 @@ public abstract class AggregatorBase implements Aggregator
             e = e.applyNodeTransform(transform) ;
         return copy(e) ;
     }
-    
+
     /** Many aggregate use a single expression.
      *  This convenience operation gets the expression if there is exactly one.
      */
@@ -102,12 +103,12 @@ public abstract class AggregatorBase implements Aggregator
             return getExprList().get(0) ;
         return null ;
     }
-    
+
     @Override
     public ExprList getExprList()           { return exprList ; }
 
     @Override
-    public String getName()                 { return name ; } 
+    public String getName()                 { return name ; }
 
     @Override
     public String toString()                { return asSparqlExpr(null) ; }
@@ -129,8 +130,8 @@ public abstract class AggregatorBase implements Aggregator
     public String toPrefixString() {
         IndentedLineBuffer x = new IndentedLineBuffer() ;
         x.append("(") ;
-        x.append(getName().toLowerCase(Locale.ROOT)) ;
-        x.incIndent(); 
+        x.append(lowercase(getName())) ;
+        x.incIndent();
         if ( isDistinct )
             x.append(" distinct") ;
         for ( Expr e : getExprList() ) {
@@ -141,7 +142,7 @@ public abstract class AggregatorBase implements Aggregator
         x.append(")") ;
         return x.asString() ;
     }
-    
+
     @Override
     public abstract int hashCode() ;
 
@@ -152,7 +153,7 @@ public abstract class AggregatorBase implements Aggregator
         if ( ! ( other instanceof Aggregator ) ) return false ;
         return equals((Aggregator)other, false) ;
     }
-    
+
     protected static final int HC_AggAvg                    =  0x170 ;
     protected static final int HC_AggAvgDistinct            =  0x171 ;
 
@@ -164,19 +165,19 @@ public abstract class AggregatorBase implements Aggregator
 
     protected static final int HC_AggMin                    =  0x176 ;
     protected static final int HC_AggMinDistinct            =  0x177 ;
-    
+
     protected static final int HC_AggMax                    =  0x178 ;
     protected static final int HC_AggMaxDistinct            =  0x179 ;
 
     protected static final int HC_AggSample                 =  0x17A ;
     protected static final int HC_AggSampleDistinct         =  0x17B ;
-    
+
     protected static final int HC_AggSum                    =  0x17C ;
     protected static final int HC_AggSumDistinct            =  0x17D ;
-    
+
     protected static final int HC_AggGroupConcat            =  0x17E ;
     protected static final int HC_AggGroupConcatDistinct    =  0x17F ;
-    
+
     protected static final int HC_AggNull                   =  0x180 ;
     protected static final int HC_AggCustom                 =  0x181 ;
 
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/FN_CollationKey.java b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/FN_CollationKey.java
index 6f98f256df..3f5d6e8eba 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/FN_CollationKey.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/FN_CollationKey.java
@@ -18,30 +18,31 @@
 
 package org.apache.jena.sparql.function.library;
 
+import static org.apache.jena.atlas.lib.Lib.lowercase;
+
 import java.nio.charset.StandardCharsets ;
 import java.util.Base64 ;
-import java.util.Locale ;
 
 import org.apache.jena.datatypes.xsd.XSDDatatype ;
 import org.apache.jena.sparql.expr.NodeValue ;
 import org.apache.jena.sparql.function.FunctionBase2 ;
 
 /** XPath and XQuery Functions and Operators 3.1
- * <p> 
+ * <p>
  * {@code fn:collation-key($key as xs:string, $collation as xs:string) as xs:base64Binary}
  */
 public class FN_CollationKey extends FunctionBase2 {
 
     // The function2 variant
-    // Function1 is default collation -> codepoint. 
-    
+    // Function1 is default collation -> codepoint.
+
     @Override
     public NodeValue exec(NodeValue v1, NodeValue v2) {
         //fn:collation-key($key as xs:string, $collation as xs:string) as xs:base64Binary
         if ( ! v1.isString() ) {}
         if ( ! v2.isString() ) {}
-        String collation = v2 == null ? "" : v2.getString().toLowerCase(Locale.ROOT); 
-        
+        String collation = v2 == null ? "" : lowercase(v2.getString());
+
         // The irony of using the lexical form of old rdf:plainLiteral (RDF 1.1 does not
         // need rdf:plainLiteral and rdf:plainLiteral should never appear in RDF)
         String x = v1.getString()+"@"+v2.getString();
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/function/scripting/ScriptFunction.java b/jena-arq/src/main/java/org/apache/jena/sparql/function/scripting/ScriptFunction.java
index f27cc98967..2807ab632f 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/function/scripting/ScriptFunction.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/function/scripting/ScriptFunction.java
@@ -18,6 +18,8 @@
 
 package org.apache.jena.sparql.function.scripting;
 
+import static org.apache.jena.atlas.lib.Lib.lowercase;
+
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.Reader;
@@ -112,7 +114,7 @@ public class ScriptFunction extends FunctionBase {
         this.name = localPart.substring(separatorPos + 1);
         this.allowList = allowList(cxt, ARQ.symCustomFunctionScriptAllowList);
 
-        String cname = lang.toLowerCase(Locale.ROOT);
+        String cname = lowercase(lang);
         switch(cname) {
             case "js":
                 // never allow these.
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/util/FmtUtils.java b/jena-arq/src/main/java/org/apache/jena/sparql/util/FmtUtils.java
index ff65b10a4e..6c171820ab 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/util/FmtUtils.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/util/FmtUtils.java
@@ -18,7 +18,8 @@
 
 package org.apache.jena.sparql.util;
 
-import java.util.Locale ;
+import static org.apache.jena.atlas.lib.Lib.uppercase;
+
 import java.util.regex.Pattern ;
 
 import org.apache.jena.atlas.io.IndentedWriter ;
@@ -46,222 +47,195 @@ import org.apache.jena.vocabulary.XSD ;
  *  @see NodeFmtLib
  */
 
-public class FmtUtils
-{
+public class FmtUtils {
     // See also riot.NodeFmtLib
 
     // Consider withdrawing non-serialization context forms of this.
     // Or a temporary SerialzationContext does not abbreviate bNodes.
-    static final String indentPrefix = "  " ;
-    public static boolean multiLineExpr = false ;
-    public static boolean printOpName = true ;
+    static final String indentPrefix = "  ";
+    public static boolean multiLineExpr = false;
+    public static boolean printOpName = true;
 
-    static NodeToLabelMap bNodeMap = new NodeToLabelMapBNode("b", false) ;
+    static NodeToLabelMap bNodeMap = new NodeToLabelMapBNode("b", false);
 
-    public static SerializationContext sCxt()
-    {
-        return sCxt(ARQConstants.getGlobalPrefixMap()) ;
+    public static SerializationContext sCxt() {
+        return sCxt(ARQConstants.getGlobalPrefixMap());
     }
 
-    public static SerializationContext sCxt(PrefixMapping pmap)
-    {
-        return new SerializationContext(pmap) ;
+    public static SerializationContext sCxt(PrefixMapping pmap) {
+        return new SerializationContext(pmap);
     }
 
     // Formatting various items
-    public static String stringForTriple( Triple triple )
-    {
+    public static String stringForTriple(Triple triple) {
         StringBuilder result = new StringBuilder();
-        stringForNode( result, triple.getSubject() );
-        result.append( " " );
-        stringForNode( result, triple.getPredicate() );
-        result.append( " " );
-        stringForNode( result, triple.getObject() );
+        stringForNode(result, triple.getSubject());
+        result.append(" ");
+        stringForNode(result, triple.getPredicate());
+        result.append(" ");
+        stringForNode(result, triple.getObject());
         return result.toString();
     }
 
-    public static String stringForTriple(Triple triple, PrefixMapping prefixMap)
-    {
-        return stringForTriple(triple, sCxt(prefixMap)) ;
+    public static String stringForTriple(Triple triple, PrefixMapping prefixMap) {
+        return stringForTriple(triple, sCxt(prefixMap));
     }
 
-    public static String stringForTriple(Triple triple, SerializationContext sCxt)
-    {
+    public static String stringForTriple(Triple triple, SerializationContext sCxt) {
         StringBuilder result = new StringBuilder();
-        stringForTriple(result, triple, sCxt) ;
+        stringForTriple(result, triple, sCxt);
         return result.toString();
     }
 
-    public static void stringForTriple(StringBuilder result, Triple triple, SerializationContext sCxt)
-    {
-        stringForNode(result, triple.getSubject(), sCxt );
-        result.append( " " );
-        stringForNode(result, triple.getPredicate(), sCxt );
-        result.append( " " );
-        stringForNode(result, triple.getObject(), sCxt );
+    public static void stringForTriple(StringBuilder result, Triple triple, SerializationContext sCxt) {
+        stringForNode(result, triple.getSubject(), sCxt);
+        result.append(" ");
+        stringForNode(result, triple.getPredicate(), sCxt);
+        result.append(" ");
+        stringForNode(result, triple.getObject(), sCxt);
     }
 
     public static String stringForQuad(Quad quad, PrefixMapping prefixMap) {
-        return stringForQuad(quad, sCxt(prefixMap)) ;
+        return stringForQuad(quad, sCxt(prefixMap));
     }
 
-    public static String stringForQuad(Quad quad)
-    {
-        StringBuilder sb = new StringBuilder() ;
+    public static String stringForQuad(Quad quad) {
+        StringBuilder sb = new StringBuilder();
 
-        if ( quad.getGraph() != null )
-        {
-            sb.append(stringForNode(quad.getGraph())) ;
-            sb.append(" ") ;
+        if ( quad.getGraph() != null ) {
+            sb.append(stringForNode(quad.getGraph()));
+            sb.append(" ");
         }
 
-        stringForNode(sb, quad.getSubject() );
-        sb.append(" ") ;
+        stringForNode(sb, quad.getSubject());
+        sb.append(" ");
         stringForNode(sb, quad.getPredicate());
-        sb.append(" ") ;
+        sb.append(" ");
         stringForNode(sb, quad.getObject());
-        return sb.toString() ;
+        return sb.toString();
     }
 
     public static String stringForQuad(Quad quad, SerializationContext sCxt) {
-        StringBuilder sb = new StringBuilder() ;
-        stringForQuad(sb, quad, sCxt) ;
-        return sb.toString() ;
+        StringBuilder sb = new StringBuilder();
+        stringForQuad(sb, quad, sCxt);
+        return sb.toString();
     }
 
-    public static void stringForQuad(StringBuilder sb, Quad quad, SerializationContext sCxt)
-    {
-        if ( quad.getGraph() != null )
-        {
-            sb.append(stringForNode(quad.getGraph(), sCxt)) ;
-            sb.append(" ") ;
+    public static void stringForQuad(StringBuilder sb, Quad quad, SerializationContext sCxt) {
+        if ( quad.getGraph() != null ) {
+            sb.append(stringForNode(quad.getGraph(), sCxt));
+            sb.append(" ");
         }
 
         stringForNode(sb, quad.getSubject(), sCxt);
-        sb.append(" ") ;
-        stringForNode( sb, quad.getPredicate(), sCxt );
-        sb.append(" ") ;
+        sb.append(" ");
+        stringForNode(sb, quad.getPredicate(), sCxt);
+        sb.append(" ");
         stringForNode(sb, quad.getObject(), sCxt);
     }
 
-    public static void formatPattern(IndentedWriter out, BasicPattern pattern, SerializationContext sCxt)
-    {
-        StringBuilder buffer = new StringBuilder() ;
-        boolean first = true ;
-        for (Triple triple : pattern )
-        {
-            if ( ! first )
-                buffer.append("\n") ;
-            stringForTriple(buffer, triple, sCxt) ;
-            buffer.append(" ." ) ;
-            out.print(buffer.toString()) ;
-            buffer.setLength(0) ;
-            first = false ;
+    public static void formatPattern(IndentedWriter out, BasicPattern pattern, SerializationContext sCxt) {
+        StringBuilder buffer = new StringBuilder();
+        boolean first = true;
+        for ( Triple triple : pattern ) {
+            if ( !first )
+                buffer.append("\n");
+            stringForTriple(buffer, triple, sCxt);
+            buffer.append(" .");
+            out.print(buffer.toString());
+            buffer.setLength(0);
+            first = false;
         }
     }
 
-    public static String stringForObject(Object obj)
-    {
+    public static String stringForObject(Object obj) {
         if ( obj == null )
-            return "<<null>>" ;
+            return "<<null>>";
 
         if ( obj instanceof RDFNode )
-            return stringForRDFNode((RDFNode)obj) ;
+            return stringForRDFNode((RDFNode)obj);
         if ( obj instanceof Node )
-            return stringForNode((Node)obj) ;
-        return obj.toString() ;
+            return stringForNode((Node)obj);
+        return obj.toString();
     }
 
-
-    public static String stringForRDFNode(RDFNode obj)
-    {
-        Model m = null ;
+    public static String stringForRDFNode(RDFNode obj) {
+        Model m = null;
         if ( obj instanceof Resource )
-            m = obj.getModel() ;
-        return stringForRDFNode(obj, newSerializationContext(m)) ;
+            m = obj.getModel();
+        return stringForRDFNode(obj, newSerializationContext(m));
     }
 
-    public static String stringForRDFNode(RDFNode obj, SerializationContext context)
-    {
-        return stringForNode(obj.asNode(), context) ;
+    public static String stringForRDFNode(RDFNode obj, SerializationContext context) {
+        return stringForNode(obj.asNode(), context);
     }
 
-    public static String stringForLiteral(Node_Literal literal, SerializationContext context)
-    {
-        StringBuilder result = new StringBuilder(  );
-        stringForLiteral( result, literal, context );
+    public static String stringForLiteral(Node_Literal literal, SerializationContext context) {
+        StringBuilder result = new StringBuilder();
+        stringForLiteral(result, literal, context);
         return result.toString();
     }
 
-    public static void stringForLiteral(StringBuilder result, Node_Literal literal, SerializationContext context)
-    {
-        String datatype = literal.getLiteralDatatypeURI() ;
-        String lang = literal.getLiteralLanguage() ;
-        String s = literal.getLiteralLexicalForm() ;
+    public static void stringForLiteral(StringBuilder result, Node_Literal literal, SerializationContext context) {
+        String datatype = literal.getLiteralDatatypeURI();
+        String lang = literal.getLiteralLanguage();
+        String s = literal.getLiteralLexicalForm();
 
-        //For some literals we can use plain literal form unless the Serialization Context
-        //explicitly says not to
-        //For backwards compatibility if using a null context then we use plain literal
-        //forms where possible as this was the existing behaviour prior to this addition to the API
-        if ( datatype != null && (context == null || context.getUsePlainLiterals()))
-        {
+        // For some literals we can use plain literal form unless the Serialization
+        // Context explicitly says not to. For backwards compatibility if using a
+        // null context then we use plain literal forms where possible as this was
+        // the existing behaviour prior to this addition to the API
+        if ( datatype != null && (context == null || context.getUsePlainLiterals()) ) {
             // Special form we know how to handle?
             // Assume valid text
-            if ( datatype.equals(XSD.integer.getURI()) )
-            {
+            if ( datatype.equals(XSD.integer.getURI()) ) {
                 try {
-                    String s1 = s ;
+                    String s1 = s;
                     // BigInteger does not allow leading +
                     // so chop it off before the format test
                     // BigDecimal does allow a leading +
                     if ( s.startsWith("+") )
-                        s1 = s.substring(1) ;
-                    new java.math.BigInteger(s1) ;
+                        s1 = s.substring(1);
+                    new java.math.BigInteger(s1);
                     result.append(s);
                     return;
                 } catch (NumberFormatException nfe) {}
-                // No luck.  Continue.
+                // No luck. Continue.
                 // Continuing is always safe.
             }
 
-            if ( datatype.equals(XSD.decimal.getURI()) )
-            {
-                if ( s.indexOf('.') > 0 )
-                {
+            if ( datatype.equals(XSD.decimal.getURI()) ) {
+                if ( s.indexOf('.') > 0 ) {
                     try {
                         // BigDecimal does allow a leading +
-                        new java.math.BigDecimal(s) ;
+                        new java.math.BigDecimal(s);
                         result.append(s);
                         return;
                     } catch (NumberFormatException nfe) {}
-                    // No luck.  Continue.
+                    // No luck. Continue.
                 }
             }
 
-            if ( datatype.equals(XSD.xdouble.getURI()) )
-            {
+            if ( datatype.equals(XSD.xdouble.getURI()) ) {
                 // Assumes SPARQL has decimals and doubles.
                 // Must have 'e' or 'E' to be a double short form.
 
-                if ( s.indexOf('e') >= 0 || s.indexOf('E') >= 0 )
-                {
+                if ( s.indexOf('e') >= 0 || s.indexOf('E') >= 0 ) {
                     try {
-                        Double.parseDouble(s) ;
+                        Double.parseDouble(s);
                         result.append(s);
                         return;  // returm the original lexical form.
                     } catch (NumberFormatException nfe) {}
-                    // No luck.  Continue.
+                    // No luck. Continue.
                 }
             }
 
-            if ( datatype.equals(XSD.xboolean.getURI()) )
-            {
+            if ( datatype.equals(XSD.xboolean.getURI()) ) {
                 // Pragmatics: if the data wrote "1"^^xsd:boolean, keep that form.
                 // The lexical form must be lower case.
-//                if ( s.equals("true") || s.equals("1") ) return s ;
-//                if ( s.equals("false") || s.equals("0")  ) return s ;
-                if ( s.equals("true") || s.equals("false"))
-                {
+                // if ( s.equals("true") || s.equals("1") ) return s ;
+                // if ( s.equals("false") || s.equals("0") ) return s ;
+                if ( s.equals("true") || s.equals("false") ) {
                     result.append(s);
                     return;
                 }
@@ -270,112 +244,101 @@ public class FmtUtils
             // Not a recognized form.
         }
 
-        result.append("\"") ;
-        stringEsc(result, s, true) ;
-        result.append("\"") ;
+        result.append("\"");
+        stringEsc(result, s, true);
+        result.append("\"");
 
         if ( NodeUtils.isSimpleString(literal) ) {
             // No op.
-            return ;
+            return;
         }
 
         if ( NodeUtils.isLangString(literal) ) {
-            result.append("@") ;
-            result.append(lang) ;
-            return ;
+            result.append("@");
+            result.append(lang);
+            return;
         }
 
-        if ( datatype != null )
-        {
-            result.append("^^") ;
-            stringForURI( result, datatype, context );
+        if ( datatype != null ) {
+            result.append("^^");
+            stringForURI(result, datatype, context);
         }
     }
 
-    public static String stringForString(String str)
-    {
-        StringBuilder sbuff = new StringBuilder() ;
-        sbuff.append("\"") ;
-        stringEsc(sbuff, str, true) ;
-        sbuff.append("\"") ;
-        return sbuff.toString() ;
+    public static String stringForString(String str) {
+        StringBuilder sbuff = new StringBuilder();
+        sbuff.append("\"");
+        stringEsc(sbuff, str, true);
+        sbuff.append("\"");
+        return sbuff.toString();
     }
 
-    public static String stringForResource(Resource r)
-    {
-        return stringForResource(r, newSerializationContext(r.getModel())) ;
+    public static String stringForResource(Resource r) {
+        return stringForResource(r, newSerializationContext(r.getModel()));
     }
 
-    public static String stringForResource(Resource r, SerializationContext context)
-    {
-        return stringForNode(r.asNode(), context) ;
+    public static String stringForResource(Resource r, SerializationContext context) {
+        return stringForNode(r.asNode(), context);
     }
 
-    public static String stringForNode(Node n)
-    {
+    public static String stringForNode(Node n) {
         StringBuilder sb = new StringBuilder();
-        stringForNode(sb, n, ARQConstants.getGlobalPrefixMap()) ;
+        stringForNode(sb, n, ARQConstants.getGlobalPrefixMap());
         return sb.toString();
     }
 
-    public static void stringForNode(StringBuilder result, Node n)
-    {
-        stringForNode( result, n, ARQConstants.getGlobalPrefixMap()) ;
+    public static void stringForNode(StringBuilder result, Node n) {
+        stringForNode(result, n, ARQConstants.getGlobalPrefixMap());
     }
 
-    public static String stringForNode(Node n, PrefixMapping prefixMap)
-    {
+    public static String stringForNode(Node n, PrefixMapping prefixMap) {
         StringBuilder sb = new StringBuilder();
-        stringForNode(sb, n, newSerializationContext(prefixMap)) ;
+        stringForNode(sb, n, newSerializationContext(prefixMap));
         return sb.toString();
     }
 
-    public static void stringForNode(StringBuilder result, Node n, PrefixMapping prefixMap)
-    {
-        stringForNode( result, n, newSerializationContext(prefixMap)) ;
+    public static void stringForNode(StringBuilder result, Node n, PrefixMapping prefixMap) {
+        stringForNode(result, n, newSerializationContext(prefixMap));
     }
 
-    public static String stringForNode(Node n, Prologue prologue)
-    {
+    public static String stringForNode(Node n, Prologue prologue) {
         StringBuilder sb = new StringBuilder();
-        stringForNode(sb, n, newSerializationContext(prologue)) ;
+        stringForNode(sb, n, newSerializationContext(prologue));
         return sb.toString();
     }
 
-    public static String stringForNode(Node n, SerializationContext context)
-    {
-        StringBuilder sb = new StringBuilder(  );
-        stringForNode( sb, n, context );
+    public static String stringForNode(Node n, SerializationContext context) {
+        StringBuilder sb = new StringBuilder();
+        stringForNode(sb, n, context);
         return sb.toString();
     }
 
-    public static void stringForNode(StringBuilder result, Node n, SerializationContext context)
-    {
+    public static void stringForNode(StringBuilder result, Node n, SerializationContext context) {
         if ( n == null ) {
-            result.append("<<null>>") ;
-            return ;
+            result.append("<<null>>");
+            return;
         }
 
         // mappable?
         if ( context != null && context.getBNodeMap() != null ) {
-            String str = context.getBNodeMap().asString(n) ;
+            String str = context.getBNodeMap().asString(n);
             if ( str != null ) {
-                result.append(str) ;
-                return ;
+                result.append(str);
+                return;
             }
         }
 
         if ( n.isBlank() ) {
-            result.append("_:").append(n.getBlankNodeLabel()) ;
+            result.append("_:").append(n.getBlankNodeLabel());
         } else if ( n.isLiteral() ) {
-            stringForLiteral(result, (Node_Literal)n, context) ;
+            stringForLiteral(result, (Node_Literal)n, context);
         } else if ( n.isURI() ) {
-            String uri = n.getURI() ;
-            stringForURI(result, uri, context) ;
+            String uri = n.getURI();
+            stringForURI(result, uri, context);
         } else if ( n.isVariable() ) {
-            result.append("?").append(n.getName()) ;
+            result.append("?").append(n.getName());
         } else if ( n.equals(Node.ANY) ) {
-            result.append("ANY") ;
+            result.append("ANY");
         } else if ( n.isNodeTriple() ) {
             Triple t = n.getTriple();
             result.append("<< ");
@@ -386,79 +349,67 @@ public class FmtUtils
             stringForNode(result, t.getObject(), context);
             result.append(" >>");
         } else if ( n.isNodeGraph() ) {
-            Log.warn(FmtUtils.class, "Can not turn a graph term node into a string") ;
+            Log.warn(FmtUtils.class, "Can not turn a graph term node into a string");
             result.append(" { graph }");
         } else {
-            Log.warn(FmtUtils.class, "Failed to turn a node into a string: " + n) ;
-            result.append(n.toString()) ;
+            Log.warn(FmtUtils.class, "Failed to turn a node into a string: " + n);
+            result.append(n.toString());
         }
     }
 
-    static public String stringForURI(String uri)
-    {
+    public static String stringForURI(String uri) {
         StringBuilder sb = new StringBuilder();
         stringForURI(sb, uri);
         return sb.toString();
     }
 
-	static public void stringForURI(StringBuilder target, String uri)
-	{
-		target.append("<");
-		stringEsc(target, uri);
-		target.append(">");
-	}
-
+    public static void stringForURI(StringBuilder target, String uri) {
+        target.append("<");
+        stringEsc(target, uri);
+        target.append(">");
+    }
 
-	static public String stringForURI(String uri, Prologue prologue)
-    {
-        return stringForURI(uri, prologue.getBaseURI(), prologue.getPrefixMapping()) ;
+    public static String stringForURI(String uri, Prologue prologue) {
+        return stringForURI(uri, prologue.getBaseURI(), prologue.getPrefixMapping());
     }
 
-    static public String stringForURI(String uri, String baseIRI)
-    {
-        return stringForURI(uri, baseIRI, null) ;
+    public static String stringForURI(String uri, String baseIRI) {
+        return stringForURI(uri, baseIRI, null);
     }
 
-    static public String stringForURI(String uri, SerializationContext context)
-    {
+    public static String stringForURI(String uri, SerializationContext context) {
         if ( context == null )
-            return stringForURI(uri, null, null) ;
-        return stringForURI(uri, context.getBaseIRI(), context.getPrefixMapping()) ;
+            return stringForURI(uri, null, null);
+        return stringForURI(uri, context.getBaseIRI(), context.getPrefixMapping());
     }
 
-    static public void stringForURI(StringBuilder result, String uri, SerializationContext context)
-    {
+    public static void stringForURI(StringBuilder result, String uri, SerializationContext context) {
         if ( context == null )
-            stringForURI(result, uri, null, null) ;
+            stringForURI(result, uri, null, null);
         else
-            stringForURI(result, uri, context.getBaseIRI(), context.getPrefixMapping()) ;
+            stringForURI(result, uri, context.getBaseIRI(), context.getPrefixMapping());
     }
 
-    static public String stringForURI(String uri, PrefixMapping mapping)
+    public static String stringForURI(String uri, PrefixMapping mapping)
     { return stringForURI(uri, null, mapping) ; }
 
-    static public String stringForURI(String uri, String base, PrefixMapping mapping)
-    {
-        StringBuilder result = new StringBuilder(  );
-        stringForURI( result, uri, base, mapping );
+    public static String stringForURI(String uri, String base, PrefixMapping mapping) {
+        StringBuilder result = new StringBuilder();
+        stringForURI(result, uri, base, mapping);
         return result.toString();
     }
 
-    static public void stringForURI(StringBuilder result, String uri, String base, PrefixMapping mapping)
-    {
-        if ( mapping != null )
-        {
-            String pname = prefixFor(uri, mapping) ;
-            if ( pname != null )
-            {
-                result.append( pname);
+    public static void stringForURI(StringBuilder result, String uri, String base, PrefixMapping mapping) {
+        if ( mapping != null ) {
+            String pname = prefixFor(uri, mapping);
+            if ( pname != null ) {
+                result.append(pname);
                 return;
             }
 
         }
-        if ( base != null )
-        {
-            String x = abbrevByBase(uri, base) ;
+        if ( base != null ) {
+            String x = abbrevByBase(uri, base);
             if ( x != null ) {
                 result.append("<");
                 result.append(x);
@@ -466,7 +417,7 @@ public class FmtUtils
                 return;
             }
         }
-        stringForURI( result, uri ) ;
+        stringForURI(result, uri);
     }
 
     public static String abbrevByBase(String uriStr, String base) {
@@ -487,65 +438,60 @@ public class FmtUtils
         return schemePattern.matcher(uriStr).matches() ;
     }
 
-    private static String prefixFor(String uri, PrefixMapping mapping)
-    {
-        if ( mapping == null ) return null ;
+    private static String prefixFor(String uri, PrefixMapping mapping) {
+        if ( mapping == null )
+            return null;
 
-        String pname = mapping.shortForm(uri) ;
+        String pname = mapping.shortForm(uri);
         if ( pname != uri && checkValidPrefixName(pname) )
-            return pname ;
-        pname = mapping.qnameFor(uri) ;
+            return pname;
+        pname = mapping.qnameFor(uri);
         if ( pname != null && checkValidPrefixName(pname) )
-            return pname ;
-        return null ;
+            return pname;
+        return null;
     }
 
-    private static boolean checkValidPrefixName(String prefixedName)
-    {
+    private static boolean checkValidPrefixName(String prefixedName) {
         // Split it to get the parts.
-        int i = prefixedName.indexOf(':') ;
+        int i = prefixedName.indexOf(':');
         if ( i < 0 )
-            throw new ARQInternalErrorException("Broken short form -- "+prefixedName) ;
-        String p = prefixedName.substring(0,i) ;
-        String x = prefixedName.substring(i+1) ;
+            throw new ARQInternalErrorException("Broken short form -- " + prefixedName);
+        String p = prefixedName.substring(0, i);
+        String x = prefixedName.substring(i + 1);
         // Check legality
         if ( checkValidPrefix(p) && checkValidLocalname(x) )
-            return true ;
-        return false ;
+            return true;
+        return false;
     }
 
-    private static boolean checkValidPrefix(String prefixStr)
-    {
-        if ( prefixStr.startsWith("_"))
+    private static boolean checkValidPrefix(String prefixStr) {
+        if ( prefixStr.startsWith("_") )
             // Should .equals??
-            return false ;
-        return checkValidLocalname(prefixStr) ;
+            return false;
+        return checkValidLocalname(prefixStr);
     }
 
-    private static boolean checkValidLocalname(String localname)
-    {
+    private static boolean checkValidLocalname(String localname) {
         if ( localname.length() == 0 )
-            return true ;
+            return true;
 
-        for ( int idx = 0 ; idx < localname.length() ; idx++ )
-        {
-            char ch = localname.charAt(idx) ;
-            if ( ! validPNameChar(ch) )
-                return false ;
+        for ( int idx = 0 ; idx < localname.length() ; idx++ ) {
+            char ch = localname.charAt(idx);
+            if ( !validPNameChar(ch) )
+                return false;
         }
 
         // Test start and end - at least one character in the name.
 
         if ( localname.endsWith(".") )
-            return false ;
+            return false;
         if ( localname.startsWith(".") )
-            return false ;
+            return false;
 
-        return true ;
+        return true;
     }
 
-    private static boolean validPNameChar(char ch)
-    {
+    private static boolean validPNameChar(char ch) {
         if ( Character.isLetterOrDigit(ch) ) return true ;
         if ( ch == '.' )    return true ;
         if ( ch == ':' )    return true ;
@@ -562,66 +508,61 @@ public class FmtUtils
     public static String stringEsc(String s)
     { return stringEsc( s, true ) ; }
 
-    public static String stringEsc(String s, boolean singleLineString)
-    {
-        StringBuilder sb = new StringBuilder() ;
-        stringEsc(sb, s, singleLineString) ;
-        return sb.toString() ;
+    public static String stringEsc(String s, boolean singleLineString) {
+        StringBuilder sb = new StringBuilder();
+        stringEsc(sb, s, singleLineString);
+        return sb.toString();
     }
 
     public static void stringEsc(StringBuilder sbuff, String s)
     { stringEsc( sbuff,  s, true ) ; }
 
-    public static void stringEsc(StringBuilder sbuff, String s, boolean singleLineString)
-    {
-        int len = s.length() ;
-        for (int i = 0; i < len; i++) {
+    public static void stringEsc(StringBuilder sbuff, String s, boolean singleLineString) {
+        int len = s.length();
+        for ( int i = 0 ; i < len ; i++ ) {
             char c = s.charAt(i);
 
             // Escape escapes and quotes
-            if (c == '\\' || c == '"' )
-            {
-                sbuff.append('\\') ;
-                sbuff.append(c) ;
-                continue ;
+            if ( c == '\\' || c == '"' ) {
+                sbuff.append('\\');
+                sbuff.append(c);
+                continue;
             }
 
-            // Characters to literally output.
-            // This would generate 7-bit safe files
-//            if (c >= 32 && c < 127)
-//            {
-//                sbuff.append(c) ;
+//            // Characters to literally output.
+//            // This would generate 7-bit safe files
+//            if ( c >= 32 && c < 127 ) {
+//                sbuff.append(c);
 //                continue;
 //            }
 
             // Whitespace
-            if ( singleLineString && ( c == '\n' || c == '\r' || c == '\f' || c == '\t' ) )
-            {
-                if (c == '\n') sbuff.append("\\n");
-                if (c == '\t') sbuff.append("\\t");
-                if (c == '\r') sbuff.append("\\r");
-                if (c == '\f') sbuff.append("\\f");
-                continue ;
+            if ( singleLineString && (c == '\n' || c == '\r' || c == '\f' || c == '\t') ) {
+                if ( c == '\n' )
+                    sbuff.append("\\n");
+                if ( c == '\t' )
+                    sbuff.append("\\t");
+                if ( c == '\r' )
+                    sbuff.append("\\r");
+                if ( c == '\f' )
+                    sbuff.append("\\f");
+                continue;
             }
 
             // Output as is (subject to UTF-8 encoding on output that is)
 
-            if ( ! applyUnicodeEscapes )
-                sbuff.append(c) ;
-            else
-            {
+            if ( !applyUnicodeEscapes )
+                sbuff.append(c);
+            else {
                 // Unicode escapes
                 // c < 32, c >= 127, not whitespace or other specials
-                if ( c >= 32 && c < 127 )
-                {
-                    sbuff.append(c) ;
-                }
-                else
-                {
-                    String hexstr = Integer.toHexString(c).toUpperCase(Locale.ROOT);
+                if ( c >= 32 && c < 127 ) {
+                    sbuff.append(c);
+                } else {
+                    String hexstr = uppercase(Integer.toHexString(c));
                     int pad = 4 - hexstr.length();
                     sbuff.append("\\u");
-                    for (; pad > 0; pad--)
+                    for ( ; pad > 0 ; pad-- )
                         sbuff.append("0");
                     sbuff.append(hexstr);
                 }
@@ -629,16 +570,16 @@ public class FmtUtils
         }
     }
 
-    static public void resetBNodeLabels() { bNodeMap = new NodeToLabelMapBNode("b", false) ; }
+    public static void resetBNodeLabels() {
+        bNodeMap = new NodeToLabelMapBNode("b", false);
+    }
 
-    private static SerializationContext newSerializationContext(PrefixMapping prefixMapping)
-    {
-        return new SerializationContext(prefixMapping, bNodeMap) ;
+    private static SerializationContext newSerializationContext(PrefixMapping prefixMapping) {
+        return new SerializationContext(prefixMapping, bNodeMap);
     }
 
-    private static SerializationContext newSerializationContext(Prologue prologue)
-    {
-        return new SerializationContext(prologue, bNodeMap) ;
+    private static SerializationContext newSerializationContext(Prologue prologue) {
+        return new SerializationContext(prologue, bNodeMap);
     }
 
 }
diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/util/RomanNumeral.java b/jena-arq/src/main/java/org/apache/jena/sparql/util/RomanNumeral.java
index 63b2d170dd..87adb212ae 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/util/RomanNumeral.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/util/RomanNumeral.java
@@ -22,6 +22,8 @@ import java.util.Locale ;
 import java.util.regex.Matcher ;
 import java.util.regex.Pattern ;
 
+import org.apache.jena.atlas.lib.Lib;
+
 /**
  * References:
  * <ul>
@@ -72,7 +74,7 @@ public class RomanNumeral
 
     // It is easier working right to left!
     public static int r2i(String lex) {
-        lex = lex.toUpperCase(Locale.ROOT) ;
+        lex = Lib.uppercase(lex) ;
 
         // This is overly permissive.
         // 1 - allows multiple reducing values
diff --git a/jena-arq/src/test/java/org/apache/jena/riot/TestSysRIOT.java b/jena-arq/src/test/java/org/apache/jena/riot/TestSysRIOT.java
index 3c7329ca20..95118dc12b 100644
--- a/jena-arq/src/test/java/org/apache/jena/riot/TestSysRIOT.java
+++ b/jena-arq/src/test/java/org/apache/jena/riot/TestSysRIOT.java
@@ -18,7 +18,8 @@
 
 package org.apache.jena.riot;
 
-import java.util.Locale;
+import static org.apache.jena.atlas.lib.Lib.lowercase;
+
 import java.util.function.Predicate;
 
 import org.apache.jena.atlas.io.IO;
@@ -42,7 +43,7 @@ public class TestSysRIOT {
     public void chooseBaseIRI_3() {
         if ( Sys.isWindows ) {
             if ( IO.exists("c:/") )
-                testChooseBaseIRI("c:", s->s.toLowerCase(Locale.ROOT).startsWith("file:///c:/"));
+                testChooseBaseIRI("c:", s->lowercase(s).startsWith("file:///c:/"));
         } else
             testChooseBaseIRI("x:", "x:");
     }
@@ -51,7 +52,7 @@ public class TestSysRIOT {
     public void chooseBaseIRI_4() {
         if ( Sys.isWindows ) {
             if ( IO.exists("c:/") )
-                testChooseBaseIRI("c:", s->s.toLowerCase(Locale.ROOT).startsWith("file:///c:/"));
+                testChooseBaseIRI("c:", s->lowercase(s).startsWith("file:///c:/"));
         } else
             testChooseBaseIRI("x:/", "x:/");
     }
diff --git a/jena-base/src/main/java/org/apache/jena/atlas/lib/Lib.java b/jena-base/src/main/java/org/apache/jena/atlas/lib/Lib.java
index 0356e6c80f..e77ab46c92 100644
--- a/jena-base/src/main/java/org/apache/jena/atlas/lib/Lib.java
+++ b/jena-base/src/main/java/org/apache/jena/atlas/lib/Lib.java
@@ -134,13 +134,13 @@ public class Lib
         return StringUtils.isEmpty(cs);
     }
 
-    /** Non-locale lowercase */
+    /** Non-locale lowercase {@link Locale#ROOT} */
     public static String lowercase(String string) {
         // Hide implementation
         return string.toLowerCase(Locale.ROOT);
     }
 
-    /** Non-locale uppercase */
+    /** Non-locale uppercase {@link Locale#ROOT} */
     public static String uppercase(String string) {
         // Hide implementation
         return string.toUpperCase(Locale.ROOT);
diff --git a/jena-base/src/test/java/org/apache/jena/atlas/junit/AssertExtra.java b/jena-base/src/test/java/org/apache/jena/atlas/junit/AssertExtra.java
index 86b685f2f2..019bc85bfa 100644
--- a/jena-base/src/test/java/org/apache/jena/atlas/junit/AssertExtra.java
+++ b/jena-base/src/test/java/org/apache/jena/atlas/junit/AssertExtra.java
@@ -19,33 +19,28 @@
 package org.apache.jena.atlas.junit ;
 
 import java.util.List ;
-import java.util.Locale ;
 
 import org.apache.jena.atlas.lib.ListUtils ;
 import org.junit.Assert ;
 
 public class AssertExtra {
     public static void assertEqualsIgnoreCase(String a, String b) {
-        a = a.toLowerCase(Locale.ROOT) ;
-        b = b.toLowerCase(Locale.ROOT) ;
-        Assert.assertEquals(a, b) ;
+        Assert.assertTrue(a.equalsIgnoreCase(b)) ;
     }
 
     public static void assertEqualsIgnoreCase(String msg, String a, String b) {
-        a = a.toLowerCase(Locale.ROOT) ;
-        b = b.toLowerCase(Locale.ROOT) ;
-        Assert.assertEquals(msg, a, b) ;
+        Assert.assertTrue(msg, a.equalsIgnoreCase(b));
     }
 
     public static <T> void assertEqualsUnordered(List<T> list1, List<T> list2) {
         assertEqualsUnordered(null, list1, list2) ;
     }
-    
+
     public static <T> void assertEqualsUnordered(String msg, List<T> list1, List<T> list2) {
         if ( ! ListUtils.equalsUnordered(list1, list2) )
             Assert.fail(msg(msg, list1, list2)) ;
     }
-    
+
     private static <T> String msg(String msg, List<T> list1, List<T> list2) {
         String x = ( msg == null ) ? "" : msg+": " ;
         x = x +"Expected: " + list1 + " : Actual: " + list2 ;
diff --git a/jena-cmds/src/main/java/arq/qparse.java b/jena-cmds/src/main/java/arq/qparse.java
index 39d7df3b1f..986ce4cf6b 100644
--- a/jena-cmds/src/main/java/arq/qparse.java
+++ b/jena-cmds/src/main/java/arq/qparse.java
@@ -18,9 +18,10 @@
 
 package arq;
 
+import static org.apache.jena.atlas.lib.Lib.lowercase;
+
 import java.io.PrintStream ;
 import java.util.Iterator ;
-import java.util.Locale;
 
 import arq.cmdline.CmdARQ ;
 import arq.cmdline.ModEngine ;
@@ -45,13 +46,13 @@ import org.apache.jena.sparql.util.QueryUtils ;
 public class qparse extends CmdARQ
 {
     protected ModQueryIn    modQuery        = new ModQueryIn(Syntax.syntaxARQ) ;
-    protected ModQueryOut   modOutput       = new ModQueryOut() ; 
+    protected ModQueryOut   modOutput       = new ModQueryOut() ;
     protected ModEngine     modEngine       = new ModEngine() ;
     protected final ArgDecl argDeclPrint    = new ArgDecl(ArgDecl.HasValue, "print") ;
     protected final ArgDecl argDeclOpt      = new ArgDecl(ArgDecl.NoValue, "opt", "optimize") ;
     protected final ArgDecl argDeclExplain  = new ArgDecl(ArgDecl.NoValue, "explain") ;
     protected final ArgDecl argDeclFixup    = new ArgDecl(ArgDecl.NoValue, "fixup") ;
-    
+
     protected boolean printNone             = false ;
     protected boolean printQuery            = false ;
     protected boolean printOp               = false ;
@@ -59,12 +60,12 @@ public class qparse extends CmdARQ
     protected boolean printQuad             = false ;
     protected boolean printQuadOpt          = false ;
     protected boolean printPlan             = false ;
-    
+
     public static void main(String... argv)
     {
         new qparse(argv).mainRun() ;
     }
-    
+
     public qparse(String[] argv)
     {
         super(argv) ;
@@ -76,16 +77,16 @@ public class qparse extends CmdARQ
         super.add(argDeclExplain, "--explain", "Print with algebra-level optimization") ;
         super.add(argDeclOpt, "--opt", "[deprecated]") ;
         super.add(argDeclFixup, "--fixup", "Convert undeclared prefix names to URIs") ;
-        
-        // Switch off function build warnings.  
+
+        // Switch off function build warnings.
         E_Function.WarnOnUnknownFunction = false ;
     }
-    
+
     @Override
     protected void processModulesAndArgs()
     {
         super.processModulesAndArgs() ;
-        
+
         if ( contains(argDeclOpt) )
             printOpt = true ;
         if ( contains(argDeclExplain) )
@@ -98,9 +99,8 @@ public class qparse extends CmdARQ
             ARQ.set(ARQ.fixupUndefinedPrefixes, true);
         }
 
-        for ( String arg : getValues( argDeclPrint ) )
-        {
-            switch(arg.toLowerCase(Locale.ROOT)) {
+        for ( String arg : getValues( argDeclPrint ) ) {
+            switch(lowercase(arg)) {
                 case "query":
                     printQuery = true;
                     break;
@@ -113,32 +113,32 @@ public class qparse extends CmdARQ
                 case "plan":
                     printPlan = true;
                     break;
-                case "opt": 
+                case "opt":
                     printOpt = true;
                     break;
                 case "optquad": case "quadopt":
                     printQuadOpt = true;
                     break;
-                case "none": 
+                case "none":
                     printNone = true;
                     break;
                 default:
                     throw new CmdException("Not a recognized print form: " + arg + " : Choices are: query, op, quad, opt, optquad, plan" );
             }
         }
-        
+
         if ( ! printQuery && ! printOp && ! printQuad && ! printPlan && ! printOpt && ! printQuadOpt && ! printNone )
             printQuery = true ;
     }
 
     static String usage = qparse.class.getName()+" [--in syntax] [--out syntax] [--print=FORM] [\"query\"] | --query <file>" ;
-    
+
     @Override
     protected String getSummary()
     {
         return usage ;
     }
-    
+
     static final String divider = "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" ;
     //static final String divider = "" ;
     boolean needDivider = false ;
@@ -147,7 +147,7 @@ public class qparse extends CmdARQ
         if ( needDivider ) System.out.println(divider) ;
         needDivider = true ;
     }
-    
+
     @Override
     protected void exec()
     {
@@ -165,7 +165,7 @@ public class qparse extends CmdARQ
             }
             finally { LogCtl.setLevel(QueryParserBase.ParserLoggerName, "INFO") ; }
 
-            
+
             // Print the query out in some syntax
             if ( printQuery )
             { divider() ; modOutput.output(query) ; }
@@ -173,22 +173,22 @@ public class qparse extends CmdARQ
             // Print internal forms.
             if ( printOp )
             { divider() ; modOutput.outputOp(query, false) ; }
-            
+
             if ( printQuad )
             { divider() ; modOutput.outputQuad(query, false) ; }
-            
+
             if ( printOpt )
             { divider() ; modOutput.outputOp(query, true) ; }
-            
+
             if ( printQuadOpt )
             { divider() ; modOutput.outputQuad(query, true) ; }
-            
+
             if ( printPlan )
-            { 
+            {
                 divider() ;
                 // This forces internal query initialization - must be after QueryUtils.checkQuery
                 QueryExecution qExec = QueryExecutionFactory.create(query, DatasetFactory.createGeneral()) ;
-                QueryOutputUtils.printPlan(query, qExec) ; 
+                QueryOutputUtils.printPlan(query, qExec) ;
             }
         }
         catch (ARQInternalErrorException intEx)
@@ -212,10 +212,10 @@ public class qparse extends CmdARQ
             //System.err.println(qEx.getMessage()) ;
             throw new CmdException("Query Exeception", qEx) ;
         }
-        catch (JenaException ex) { 
+        catch (JenaException ex) {
             ex.printStackTrace() ;
-            throw ex ; } 
-        catch (CmdException ex) { throw ex ; } 
+            throw ex ; }
+        catch (CmdException ex) { throw ex ; }
         catch (Exception ex)
         {
             throw new CmdException("Exception", ex) ;
@@ -236,7 +236,7 @@ public class qparse extends CmdARQ
 //            "  --parse        Parse only - don't print\n"+
 //            "  ---planning    Turn planning on/off\n"+
 //            "  --show X       Show internal structure (X = query or plan)\n" ;
-    
+
     static void writeSyntaxes(String msg, PrintStream out)
     {
         if ( msg != null )
@@ -255,6 +255,6 @@ public class qparse extends CmdARQ
         StringBuilder r = new StringBuilder(x) ;
         for ( int i = x.length() ; i <= len ; i++ )
             r.append(" ") ;
-        return r.toString() ; 
+        return r.toString() ;
     }
 }
diff --git a/jena-core/src/main/java/org/apache/jena/graph/impl/CollectionGraph.java b/jena-core/src/main/java/org/apache/jena/graph/impl/CollectionGraph.java
index cf14b8c17e..38826305c0 100644
--- a/jena-core/src/main/java/org/apache/jena/graph/impl/CollectionGraph.java
+++ b/jena-core/src/main/java/org/apache/jena/graph/impl/CollectionGraph.java
@@ -19,12 +19,10 @@ package org.apache.jena.graph.impl;
 
 import java.util.Collection ;
 import java.util.HashSet ;
-import java.util.Locale ;
 import java.util.Set ;
 
 import org.apache.jena.graph.Capabilities ;
 import org.apache.jena.graph.Node ;
-import org.apache.jena.graph.NodeFactory ;
 import org.apache.jena.graph.Triple ;
 import org.apache.jena.util.iterator.ExtendedIterator ;
 
@@ -53,24 +51,9 @@ public class CollectionGraph extends GraphBase
     }
 
     private static boolean equalNode(Node m, Node n) {
-        n = fixupNode(n);
-        m = fixupNode(m);
         return (m == null) || (m == Node.ANY) || m.equals(n);
     }
 
-    private static Node fixupNode(Node node) {
-        if ( node == null || node == Node.ANY )
-            return node;
-
-        // RDF says ... language tags should be canonicalized to lower case.
-        if ( node.isLiteral() ) {
-            String lang = node.getLiteralLanguage();
-            if ( lang != null && !lang.equals("") )
-                node = NodeFactory.createLiteralLang(node.getLiteralLexicalForm(), lang.toLowerCase(Locale.ROOT));
-        }
-        return node;
-    }
-
     // the collection
     private final Collection<Triple> triples;
     private final boolean uniqueOnly;
diff --git a/jena-core/src/test/java/org/apache/jena/irix/TestIRIxSyntax.java b/jena-core/src/test/java/org/apache/jena/irix/TestIRIxSyntax.java
index ff161aa482..ae51671fe9 100644
--- a/jena-core/src/test/java/org/apache/jena/irix/TestIRIxSyntax.java
+++ b/jena-core/src/test/java/org/apache/jena/irix/TestIRIxSyntax.java
@@ -18,7 +18,7 @@
 
 package org.apache.jena.irix;
 
-import java.util.Locale;
+import static org.apache.jena.atlas.lib.Lib.uppercase;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -99,13 +99,13 @@ public class TestIRIxSyntax extends AbstractTestIRIx {
 
     @Test public void parse_uuid_01() { parse("uuid:"+testUUID); }
 
-    @Test public void parse_uuid_02() { parse("uuid:"+(testUUID.toUpperCase(Locale.ROOT))); }
+    @Test public void parse_uuid_02() { parse("uuid:"+uppercase(testUUID)); }
 
     @Test public void parse_uuid_03() { parse("UUID:"+testUUID); }
 
     @Test public void parse_uuid_04() { parse("urn:uuid:"+testUUID); }
 
-    @Test public void parse_uuid_05() { parse("urn:uuid:"+(testUUID.toUpperCase(Locale.ROOT))); }
+    @Test public void parse_uuid_05() { parse("urn:uuid:"+uppercase(testUUID)); }
 
     @Test public void parse_uuid_06() { parse("URN:UUID:"+testUUID); }
 
diff --git a/jena-core/src/test/java/org/apache/jena/irix/TestRFC3986.java b/jena-core/src/test/java/org/apache/jena/irix/TestRFC3986.java
index b2f39acf2a..474ac7a82d 100644
--- a/jena-core/src/test/java/org/apache/jena/irix/TestRFC3986.java
+++ b/jena-core/src/test/java/org/apache/jena/irix/TestRFC3986.java
@@ -18,12 +18,11 @@
 
 package org.apache.jena.irix;
 
+import static org.apache.jena.atlas.lib.Lib.uppercase;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.fail;
 
-import java.util.Locale;
-
 import org.apache.jena.iri.IRI;
 import org.junit.FixMethodOrder;
 import org.junit.Test;
@@ -261,7 +260,7 @@ public class TestRFC3986 extends AbstractTestIRIx {
 
     @Test public void parse_uuid_01() { good("uuid:"+testUUID); }
 
-    @Test public void parse_uuid_02() { good("uuid:"+(testUUID.toUpperCase(Locale.ROOT))); }
+    @Test public void parse_uuid_02() { good("uuid:"+(uppercase(testUUID))); }
 
     @Test public void parse_uuid_bad_01() { badSpecific("uuid:06e775ac-2c38-11b2-801c-8086f2cc00c9?query=foo"); }
 
@@ -291,7 +290,7 @@ public class TestRFC3986 extends AbstractTestIRIx {
 
     @Test public void parse_urn_uuid_01() { good("urn:uuid:"+testUUID); }
 
-    @Test public void parse_urn_uuid_02() { good("urn:uuid:"+(testUUID.toUpperCase(Locale.ROOT))); }
+    @Test public void parse_urn_uuid_02() { good("urn:uuid:"+uppercase(testUUID)); }
 
     @Test public void parse_urn_uuid_03() { parse_uuid_8141("urn:uuid:"+testUUID+"#frag"); }
 
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/Operation.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/Operation.java
index db34a3dd17..5b1ef7536f 100644
--- a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/Operation.java
+++ b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/Operation.java
@@ -18,8 +18,9 @@
 
 package org.apache.jena.fuseki.server;
 
+import static org.apache.jena.atlas.lib.Lib.lowercase;
+
 import java.util.HashMap;
-import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 
@@ -73,7 +74,7 @@ public class Operation {
         // Currently, (3.13.0) the JS name is the short display name in lower
         // case. Just in case it diverges in the future, leave provision for
         // a different setting.
-        return new Operation(id, shortName, shortName.toLowerCase(Locale.ROOT), description);
+        return new Operation(id, shortName, lowercase(shortName), description);
     }
 
     public static final Operation Query    = alloc(FusekiVocab.opQuery.asNode(),   "query",   "SPARQL Query");
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionREST.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionREST.java
index b1bdacebf6..44dc655d70 100644
--- a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionREST.java
+++ b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionREST.java
@@ -18,11 +18,10 @@
 
 package org.apache.jena.fuseki.servlets;
 
+import static org.apache.jena.atlas.lib.Lib.uppercase;
 import static org.apache.jena.fuseki.servlets.ActionExecLib.incCounter;
 import static org.apache.jena.riot.web.HttpNames.*;
 
-import java.util.Locale;
-
 import org.apache.jena.fuseki.server.CounterName;
 import org.apache.jena.sparql.core.DatasetGraph;
 
@@ -36,7 +35,7 @@ public abstract class ActionREST extends ActionService
     @Override
     public void execute(HttpAction action) {
         // Intercept to put counters around calls.
-        String method = action.getRequestMethod().toUpperCase(Locale.ROOT);
+        String method = uppercase(action.getRequestMethod());
 
         if (method.equals(METHOD_GET))
             doGet$(action);
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ResponseOps.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ResponseOps.java
index 0785133781..d98afc439a 100644
--- a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ResponseOps.java
+++ b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ResponseOps.java
@@ -18,19 +18,19 @@
 
 package org.apache.jena.fuseki.servlets;
 
+import static org.apache.jena.atlas.lib.Lib.lowercase;
+
 import java.io.IOException;
-import java.util.Locale;
 import java.util.Map;
 
 import jakarta.servlet.http.HttpServletRequest;
-
 import org.apache.jena.riot.WebContent;
 import org.apache.jena.riot.web.HttpNames;
 
 class ResponseOps {
     // Helpers
     public static void put(Map<String, String> map, String key, String value) {
-        map.put(key.toLowerCase(Locale.ROOT), value);
+        map.put(lowercase(key), value);
     }
 
     public static boolean isEOFexception(IOException ioEx) {
@@ -64,7 +64,7 @@ class ResponseOps {
         if ( str == null )
             return null;
         // Force keys to lower case. See put() above.
-        String key = str.toLowerCase(Locale.ROOT);
+        String key = lowercase(str);
         String str2 = map.get(key);
         if ( str2 == null )
             return str;
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/SPARQLQueryProcessor.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/SPARQLQueryProcessor.java
index fb1f3f1fb8..ab91c0fbe0 100644
--- a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/SPARQLQueryProcessor.java
+++ b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/SPARQLQueryProcessor.java
@@ -19,6 +19,7 @@
 package org.apache.jena.fuseki.servlets;
 
 import static java.lang.String.format;
+import static org.apache.jena.atlas.lib.Lib.uppercase;
 import static org.apache.jena.fuseki.server.CounterName.QueryTimeouts;
 import static org.apache.jena.fuseki.servlets.ActionExecLib.incCounter;
 import static org.apache.jena.riot.WebContent.ctHTMLForm;
@@ -111,7 +112,7 @@ public abstract class SPARQLQueryProcessor extends ActionService
      */
     @Override
     public void validate(HttpAction action) {
-        String method = action.getRequestMethod().toUpperCase(Locale.ROOT);
+        String method = uppercase(action.getRequestMethod());
 
         if ( HttpNames.METHOD_OPTIONS.equals(method) )
             return;
diff --git a/jena-fuseki2/jena-fuseki-webapp/src/main/java/org/apache/jena/fuseki/mgt/ActionDatasets.java b/jena-fuseki2/jena-fuseki-webapp/src/main/java/org/apache/jena/fuseki/mgt/ActionDatasets.java
index 52852205fe..e62215c495 100644
--- a/jena-fuseki2/jena-fuseki-webapp/src/main/java/org/apache/jena/fuseki/mgt/ActionDatasets.java
+++ b/jena-fuseki2/jena-fuseki-webapp/src/main/java/org/apache/jena/fuseki/mgt/ActionDatasets.java
@@ -19,6 +19,7 @@
 package org.apache.jena.fuseki.mgt;
 
 import static java.lang.String.format;
+import static org.apache.jena.atlas.lib.Lib.lowercase;
 import static org.apache.jena.fuseki.build.FusekiPrefixes.PREFIXES;
 
 import java.io.IOException;
@@ -477,7 +478,7 @@ public class ActionDatasets extends ActionContainerItem {
 
         //action.log.info(format("[%d] Create database : name = %s, type = %s", action.id, dbName, dbType ));
 
-        String template = dbTypeToTemplate.get(dbType.toLowerCase(Locale.ROOT));
+        String template = dbTypeToTemplate.get(lowercase(dbType));
         if ( template == null )
             ServletOps.errorBadRequest(format("dbType can be only '%s', '%s' or '%s'", tDatabaseTDB, tDatabaseTDB2, tDatabaseMem));
 
diff --git a/jena-rdfpatch/src/main/java/org/apache/jena/rdfpatch/PatchHeader.java b/jena-rdfpatch/src/main/java/org/apache/jena/rdfpatch/PatchHeader.java
index 0bd2e063cc..26f1a7e857 100644
--- a/jena-rdfpatch/src/main/java/org/apache/jena/rdfpatch/PatchHeader.java
+++ b/jena-rdfpatch/src/main/java/org/apache/jena/rdfpatch/PatchHeader.java
@@ -18,7 +18,8 @@
 
 package org.apache.jena.rdfpatch;
 
-import java.util.Locale;
+import static org.apache.jena.atlas.lib.Lib.lowercase;
+
 import java.util.Map;
 import java.util.function.BiConsumer;
 import java.util.stream.Collectors;
@@ -82,7 +83,7 @@ public class PatchHeader {
     }
 
     private static String lc(String str) {
-        return str.toLowerCase(Locale.ROOT);
+        return lowercase(str);
     }
 
     @Override
diff --git a/jena-rdfpatch/src/main/java/org/apache/jena/rdfpatch/filelog/FilePolicy.java b/jena-rdfpatch/src/main/java/org/apache/jena/rdfpatch/filelog/FilePolicy.java
index a487ba0374..4657803375 100644
--- a/jena-rdfpatch/src/main/java/org/apache/jena/rdfpatch/filelog/FilePolicy.java
+++ b/jena-rdfpatch/src/main/java/org/apache/jena/rdfpatch/filelog/FilePolicy.java
@@ -18,7 +18,8 @@
 
 package org.apache.jena.rdfpatch.filelog;
 
-import java.util.Locale;
+import static org.apache.jena.atlas.lib.Lib.lowercase;
+
 import java.util.Objects;
 
 import org.apache.jena.rdfpatch.filelog.rotate.FileRotateException;
@@ -52,7 +53,7 @@ public enum FilePolicy {
 
     public static FilePolicy policy(String name) {
         Objects.requireNonNull(name);
-        String nameLC = name.toLowerCase(Locale.ROOT);
+        String nameLC = lowercase(name);
         switch(nameLC) {
             case "date" :       return DATE;
             case "timestamp" :  return TIMESTAMP;
diff --git a/jena-shex/src/main/java/org/apache/jena/shex/expressions/NodeKind.java b/jena-shex/src/main/java/org/apache/jena/shex/expressions/NodeKind.java
index 9ddc5809ab..85938b6291 100644
--- a/jena-shex/src/main/java/org/apache/jena/shex/expressions/NodeKind.java
+++ b/jena-shex/src/main/java/org/apache/jena/shex/expressions/NodeKind.java
@@ -18,8 +18,7 @@
 
 package org.apache.jena.shex.expressions;
 
-import java.util.Locale;
-
+import org.apache.jena.atlas.lib.Lib;
 import org.apache.jena.shex.ShexException;
 
 public enum NodeKind {
@@ -30,7 +29,7 @@ public enum NodeKind {
 
     NodeKind(String string) {
         this.label = string;
-        this.ucLabel = string.toUpperCase(Locale.ROOT);
+        this.ucLabel = Lib.uppercase(string);
     }
 
     public static NodeKind create(String nodeKind) {
diff --git a/jena-shex/src/main/java/org/apache/jena/shex/writer/WriterShExC.java b/jena-shex/src/main/java/org/apache/jena/shex/writer/WriterShExC.java
index 19b07d730f..9f3ecf942d 100644
--- a/jena-shex/src/main/java/org/apache/jena/shex/writer/WriterShExC.java
+++ b/jena-shex/src/main/java/org/apache/jena/shex/writer/WriterShExC.java
@@ -18,9 +18,10 @@
 
 package org.apache.jena.shex.writer;
 
+import static org.apache.jena.atlas.lib.Lib.uppercase;
+
 import java.io.OutputStream;
 import java.util.List;
-import java.util.Locale;
 import java.util.function.Consumer;
 
 import org.apache.jena.atlas.io.AWriter;
@@ -356,7 +357,7 @@ public class WriterShExC {
         @Override
         public void visit(StrLengthConstraint constraint) {
             //stringLength       ::=      "LENGTH" | "MINLENGTH" | "MAXLENGTH"
-            out.print(constraint.getLengthType().label().toUpperCase(Locale.ROOT));
+            out.print(uppercase(constraint.getLengthType().label()));
             out.print(" ");
             out.print(Integer.toString(constraint.getLength()));
         }
@@ -368,7 +369,7 @@ public class WriterShExC {
 
         @Override
         public void visit(NodeKindConstraint constraint) {
-            out.print(constraint.getNodeKind().label().toUpperCase(Locale.ROOT));
+            out.print(uppercase(constraint.getNodeKind().label()));
         }
 
         // [30]        numericFacet       ::=      numericRange numericLiteral | numericLength INTEGER
@@ -376,7 +377,7 @@ public class WriterShExC {
         @Override
         public void visit(NumLengthConstraint constraint) {
             // [32]        numericLength      ::=      "TOTALDIGITS" | "FRACTIONDIGITS"
-            out.print(constraint.getLengthType().label().toUpperCase(Locale.ROOT));
+            out.print(uppercase(constraint.getLengthType().label()));
             out.print(" ");
             out.print(Integer.toString(constraint.getLength()));
         }
@@ -384,7 +385,7 @@ public class WriterShExC {
         @Override
         public void visit(NumRangeConstraint constraint) {
             // [31]        numericRange       ::=      "MININCLUSIVE" | "MINEXCLUSIVE" | "MAXINCLUSIVE" | "MAXEXCLUSIVE"
-            out.print(constraint.getRangeKind().label().toUpperCase(Locale.ROOT));
+            out.print(uppercase(constraint.getRangeKind().label()));
             out.print(" ");
             printNode(constraint.getValue());
         }