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

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

commit 86c2885e3bf2ae8a018f6e4885ce7464d6ea450e
Author: Rob Vesse <[email protected]>
AuthorDate: Mon Nov 9 10:44:03 2026 +0000

    Consolidate SPARQL Limits into central location
    
    Adds new SparqlLimits, which replaces previously introduced MathLimits,
    as a central location for configuring relevant limit controls and
    generic enforcement functions.
    
    Also simplifies some test case names as requested
---
 .../MathLimits.java => SparqlLimits.java}          | 95 ++++++++++++++++++++--
 .../optimize/TransformPathFlattenAlgebra.java      |  7 +-
 .../org/apache/jena/sparql/expr/RegexEngine.java   | 33 ++------
 .../jena/sparql/function/library/Math_exp.java     |  4 +-
 .../jena/sparql/function/library/Math_exp10.java   |  6 +-
 .../jena/sparql/function/library/Math_pow.java     |  6 +-
 .../function/library/leviathan/cartesian.java      | 12 +--
 .../sparql/function/library/leviathan/cube.java    |  8 +-
 .../function/library/leviathan/factorial.java      |  4 +-
 .../sparql/function/library/leviathan/pow.java     |  4 +-
 .../function/library/leviathan/pythagoras.java     |  6 +-
 .../sparql/function/library/leviathan/root.java    |  4 +-
 .../jena/sparql/function/library/leviathan/sq.java |  8 +-
 .../org/apache/jena/sparql/path/PathCompiler.java  | 35 +-------
 .../jena/sparql/pfunction/library/strSplit.java    |  4 +-
 .../test/java/org/apache/jena/sparql/TC_ARQ.java   |  3 +
 .../TestMathLimits.java => TestSparqlLimits.java}  | 13 ++-
 .../algebra/optimize/TestTransformPathFlatten.java |  9 +-
 .../org/apache/jena/sparql/expr/TestRegex.java     | 22 +++--
 .../function/library/TS_LibraryFunctions.java      |  2 +-
 .../sparql/pfunction/library/TestStrSplit.java     | 18 ++--
 21 files changed, 174 insertions(+), 129 deletions(-)

diff --git 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/MathLimits.java 
b/jena-arq/src/main/java/org/apache/jena/sparql/SparqlLimits.java
similarity index 55%
rename from 
jena-arq/src/main/java/org/apache/jena/sparql/function/MathLimits.java
rename to jena-arq/src/main/java/org/apache/jena/sparql/SparqlLimits.java
index 07edcc67a5..09a6d49e05 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/function/MathLimits.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/SparqlLimits.java
@@ -19,32 +19,54 @@
  *   SPDX-License-Identifier: Apache-2.0
  */
 
-package org.apache.jena.sparql.function;
+package org.apache.jena.sparql;
 
 import org.apache.jena.sparql.expr.ExprEvalException;
 
 import java.math.BigInteger;
+import java.text.CharacterIterator;
 
 /**
- * Static limits that control what's permitted for some math computations 
accessible via the various SPARQL function
- * libraries
+ * Static limits that control what's permitted for some SPARQL compilation, 
optimisation and expression evaluation
+ * <p>
+ * These are protective controls that allow a system operator to set limits on 
some potentially problematic aspects of
+ * SPARQL behaviour.  The following limits are currently exposed:
+ * </p>
+ * <ul>
+ *     <li>{@link #MAX_EXPONENT_DIGITS}</li>
+ *     <li>{@link #MAX_FACTORIAL_DIGITS}</li>
+ *     <li>{@link #MAX_LENGTH_PATH_FOR_REDUCTION}</li>
+ *     <li>{@link #MAX_REGEX_EVALUATION_TIME}</li>
+ * </ul>
  */
-public class MathLimits {
-
-    private MathLimits() {
+public class SparqlLimits {
+    private SparqlLimits() {
 
     }
 
+    // Mathematical computation related limits
+    // These are specifically around exponentiation and factorials
+
     /**
      * Default maximum digits used for {@link #MAX_EXPONENT_DIGITS} and {@link 
#MAX_FACTORIAL_DIGITS}
      */
     public static final int DEFAULT_MAX_DIGITS = 64;
     /**
      * Configurable maximum number of digits for an exponent calculation
+     * <p>
+     * Any mathematical function that involves exponentiation can require 
large amounts of computation, and potentially
+     * produce an output vastly larger than its inputs.  By restricting the 
maximum number of digits such computations
+     * may produce we avoid excessive computation.
+     * </p>
      */
     public static int MAX_EXPONENT_DIGITS = DEFAULT_MAX_DIGITS;
     /**
      * Configurable maximum number of digits for a factorial calculation
+     * <p>
+     * A factorial computation may involve many calculations and depending on 
input produce a vastly larger output than
+     * the input.  By restricting the maximum number of digits such 
computations may produce we avoid excessive
+     * computation.
+     * </p>
      */
     public static int MAX_FACTORIAL_DIGITS = DEFAULT_MAX_DIGITS;
 
@@ -141,4 +163,65 @@ public class MathLimits {
             throw new ExprEvalException("Calculating this factorial would 
produce too many digits");
         }
     }
+
+    // Path Compilation related limits
+
+    /**
+     * Default maximum length value used for the {@link 
#MAX_LENGTH_PATH_FOR_REDUCTION} control
+     */
+    public static final int DEFAULT_MAX_PATH_REDUCTION_LENGTH = 5;
+    /**
+     * Specifies the maximum length (inclusive) of a path that will be reduced 
by expanding it into individual
+     * invocations of the path expression linked by intermediate variables.  
Defaults to
+     * {@value #DEFAULT_MAX_PATH_REDUCTION_LENGTH}.
+     * <p>
+     * This control prevents a query using a path like {@code :x :p{N} :y} 
with a large value of {@code N} being
+     * expanded into a massive algebra tree that yields no performance 
benefits.
+     * </p>
+     *
+     * @see #isReducibleLength(long)
+     */
+    public static int MAX_LENGTH_PATH_FOR_REDUCTION = 
DEFAULT_MAX_PATH_REDUCTION_LENGTH;
+
+    /**
+     * Checks whether a given length of path is considered reducible
+     * <p>
+     * Only paths that are non-zero length and less than, or equal to, the 
configured
+     * {@link #MAX_LENGTH_PATH_FOR_REDUCTION} (default {@value 
#DEFAULT_MAX_PATH_REDUCTION_LENGTH}) are considered
+     * reducible.  Anything else is left as-is as either reduction would 
change semantics (for zero-length paths), or
+     * could lead to very large algebra trees which would negatively impact 
performance.
+     * </p>
+     *
+     * @param N Path length
+     * @return True if reducible, false otherwise
+     */
+    public static boolean isReducibleLength(long N) {
+        return N > 0 && N <= MAX_LENGTH_PATH_FOR_REDUCTION;
+    }
+
+    // Regular Expression related limits
+
+    /**
+     * Default maximum permitted regular expression evaluation time
+     *
+     * @see #MAX_REGEX_EVALUATION_TIME
+     */
+    public static final long DEFAULT_MAX_REGEX_EVALUATION_TIME = 250;
+    /**
+     * Maximum permitted regular expression evaluation time, defaults to 
{@link #DEFAULT_MAX_REGEX_EVALUATION_TIME}
+     * <p>
+     * For some regular expression patterns the evaluation time can be 
excessive, especially if a pattern, or the
+     * pattern combined with the data leads to catastrophic backtracking.  
Therefore, we bound the evaluation time by
+     * using a special {@link CharSequence}/{@link CharacterIterator} wrapper 
that enforces a time limit.  If the limit
+     * is exceeded then an {@link ExprEvalException} is thrown.  This does 
impose a small performance penalty though
+     * this is negligible and considered an acceptable trade-off for the 
protection it provides.
+     * </p>
+     * <p>
+     * If an application makes extensive use of complex regular expressions, 
and you are certain that those are not
+     * subject to catastrophic backtracking you can either increase the limit 
appropriately.  Or you can set to a
+     * zero/negative value to disable the limit entirely.
+     * </p>
+     */
+    public static long MAX_REGEX_EVALUATION_TIME = 
DEFAULT_MAX_REGEX_EVALUATION_TIME;
+
 }
diff --git 
a/jena-arq/src/main/java/org/apache/jena/sparql/algebra/optimize/TransformPathFlattenAlgebra.java
 
b/jena-arq/src/main/java/org/apache/jena/sparql/algebra/optimize/TransformPathFlattenAlgebra.java
index 7ca46df3a5..26394e28fa 100644
--- 
a/jena-arq/src/main/java/org/apache/jena/sparql/algebra/optimize/TransformPathFlattenAlgebra.java
+++ 
b/jena-arq/src/main/java/org/apache/jena/sparql/algebra/optimize/TransformPathFlattenAlgebra.java
@@ -28,6 +28,7 @@ import org.apache.jena.graph.Node ;
 import org.apache.jena.graph.Triple ;
 import org.apache.jena.sparql.ARQConstants ;
 import org.apache.jena.sparql.ARQException ;
+import org.apache.jena.sparql.SparqlLimits;
 import org.apache.jena.sparql.algebra.Op ;
 import org.apache.jena.sparql.algebra.TransformCopy ;
 import org.apache.jena.sparql.algebra.op.*;
@@ -175,7 +176,7 @@ public class TransformPathFlattenAlgebra extends 
TransformCopy {
         @Override
         public void visit(P_Mod pathMod) {
             if (pathMod.isFixedLength()) {
-                if (PathCompiler.isReducibleLength(pathMod.getFixedLength())) {
+                if (SparqlLimits.isReducibleLength(pathMod.getFixedLength())) {
                     // Treat as a fixed length path and convert that way 
instead
                     Path p = PathFactory.pathFixedLength(pathMod.getSubPath(), 
pathMod.getFixedLength());
                     Op op = transformPath(null, subject, p, object);
@@ -223,7 +224,7 @@ public class TransformPathFlattenAlgebra extends 
TransformCopy {
 
             // If the max length is very large the reduction is unlikely to 
benefit performance and just generates an
             // unnecessarily large algebra tree
-            if (!PathCompiler.isReducibleLength(pathMod.getMax())) {
+            if (!SparqlLimits.isReducibleLength(pathMod.getMax())) {
                 result = null;
                 return;
             }
@@ -239,7 +240,7 @@ public class TransformPathFlattenAlgebra extends 
TransformCopy {
 
         @Override
         public void visit(P_FixedLength pFixedLength) {
-            if (!PathCompiler.isReducibleLength(pFixedLength.getCount())) {
+            if (!SparqlLimits.isReducibleLength(pFixedLength.getCount())) {
                 // Don't transform zero length or too long paths
                 result = null;
                 return;
diff --git 
a/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java 
b/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java
index 96812f5eae..6e0780ef38 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java
@@ -33,6 +33,7 @@ import org.apache.jena.ext.xerces_regex.RegexParseException;
 import org.apache.jena.ext.xerces_regex.RegularExpression;
 import org.apache.jena.query.ARQ;
 import org.apache.jena.sparql.ARQConstants;
+import org.apache.jena.sparql.SparqlLimits;
 import org.apache.jena.sparql.util.Context;
 import org.apache.jena.sparql.util.Symbol;
 
@@ -49,28 +50,6 @@ import org.apache.jena.sparql.util.Symbol;
  */
 public abstract class RegexEngine {
 
-    /**
-     * Default maximum permitted regular expression evaluation time
-     * @see #MAX_REGEX_EVALUATION_TIME
-     */
-    public static final long DEFAULT_MAX_REGEX_EVALUATION_TIME = 250;
-    /**
-     * Maximum permitted regular expression evaluation time, defaults to 
{@link #DEFAULT_MAX_REGEX_EVALUATION_TIME}
-     * <p>
-     * For some regular expression patterns the evaluation time can be 
excessive, especially if a pattern, or the
-     * pattern combined with the data leads to catastrophic backtracking.  
Therefore, we bound the evaluation time by
-     * using a special {@link CharSequence}/{@link CharacterIterator} wrapper 
that enforces a time limit.  If the limit
-     * is exceeded then an {@link ExprEvalException} is thrown.  This does 
impose a small performance penalty though
-     * this generally should be negligible.
-     * </p>
-     * <p>
-     * If an application makes extensive use of complex regular expressions, 
and you are certain that those are not
-     * subject to catastrophic backtracking you can either increase the limit 
appropriately.  Or you can set to a
-     * zero/negative value to disable the limit entirely.
-     * </p>
-     */
-    public static long MAX_REGEX_EVALUATION_TIME = 
DEFAULT_MAX_REGEX_EVALUATION_TIME;
-
     public abstract boolean match(String string);
 
     // ---- ----
@@ -174,8 +153,8 @@ public abstract class RegexEngine {
 
         @Override
         public boolean match(String s) {
-            if (MAX_REGEX_EVALUATION_TIME > 0) {
-                return regexPattern.matches(new TimeBoundedCharSequence(s, 
MAX_REGEX_EVALUATION_TIME));
+            if (SparqlLimits.MAX_REGEX_EVALUATION_TIME > 0) {
+                return regexPattern.matches(new TimeBoundedCharSequence(s, 
SparqlLimits.MAX_REGEX_EVALUATION_TIME));
             } else {
                 return regexPattern.matches(s);
             }
@@ -206,7 +185,7 @@ public abstract class RegexEngine {
     /**
      * Returns a potentially time-bounded character sequence
      * <p>
-     * If {@link #MAX_REGEX_EVALUATION_TIME} is set to a positive non-zero 
value then a time-bounded
+     * If {@link SparqlLimits#MAX_REGEX_EVALUATION_TIME} is set to a positive 
non-zero value then a time-bounded
      * {@link CharSequence} is returned to prevent regular expression 
evaluation taking too long.  If it's set to
      * anything else then the original character sequence is returned.
      * </p>
@@ -217,8 +196,8 @@ public abstract class RegexEngine {
         if (charSequence == null) {
             return null;
         }
-        if (RegexEngine.MAX_REGEX_EVALUATION_TIME > 0) {
-            return new TimeBoundedCharSequence(charSequence, 
RegexEngine.MAX_REGEX_EVALUATION_TIME);
+        if (SparqlLimits.MAX_REGEX_EVALUATION_TIME > 0) {
+            return new TimeBoundedCharSequence(charSequence, 
SparqlLimits.MAX_REGEX_EVALUATION_TIME);
         } else {
             return charSequence;
         }
diff --git 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_exp.java 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_exp.java
index 9352c754da..5e35d62ef6 100644
--- 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_exp.java
+++ 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_exp.java
@@ -23,7 +23,7 @@ package org.apache.jena.sparql.function.library;
 
 import org.apache.jena.sparql.expr.NodeValue;
 import org.apache.jena.sparql.function.FunctionBase1;
-import org.apache.jena.sparql.function.MathLimits;
+import org.apache.jena.sparql.SparqlLimits;
 
 // Returns the value of e^x.
 public class Math_exp extends FunctionBase1 {
@@ -42,7 +42,7 @@ public class Math_exp extends FunctionBase1 {
         }
 
         // Otherwise pre-validate exponent calculation before proceeding to 
calculate it
-        MathLimits.preValidateExponentCalculation(Math.E, d);
+        SparqlLimits.preValidateExponentCalculation(Math.E, d);
         return NodeValue.makeDouble(Math.exp(d));
     }
 
diff --git 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_exp10.java
 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_exp10.java
index c9270157b2..9f15a343c0 100644
--- 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_exp10.java
+++ 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_exp10.java
@@ -27,7 +27,7 @@ import org.apache.jena.sparql.ARQInternalErrorException;
 import org.apache.jena.sparql.expr.NodeValue;
 import org.apache.jena.sparql.expr.nodevalue.XSDFuncOp;
 import org.apache.jena.sparql.function.FunctionBase1;
-import org.apache.jena.sparql.function.MathLimits;
+import org.apache.jena.sparql.SparqlLimits;
 
 // Returns the value of natural log(x)
 public class Math_exp10 extends FunctionBase1 {
@@ -39,7 +39,7 @@ public class Math_exp10 extends FunctionBase1 {
             case OP_INTEGER:
                 int x = v.getInteger().intValue();
                 if ( x >= 0 ) {
-                    MathLimits.preValidateExponentCalculation(BigInteger.TEN, 
v.getInteger());
+                    
SparqlLimits.preValidateExponentCalculation(BigInteger.TEN, v.getInteger());
                     return NodeValue.makeInteger(BigInteger.TEN.pow(x));
                 }
                 // Anything else -> double
@@ -47,7 +47,7 @@ public class Math_exp10 extends FunctionBase1 {
             case OP_DECIMAL:
             case OP_FLOAT:
             case OP_DOUBLE:
-                MathLimits.preValidateExponentCalculation(10, v.getDouble());
+                SparqlLimits.preValidateExponentCalculation(10, v.getDouble());
                 return NodeValue.makeDouble(Math.pow(10, v.getDouble()));
             default:
                 throw new ARQInternalErrorException("Unrecognized numeric 
operation : "+ v);
diff --git 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_pow.java 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_pow.java
index 95b3ca44e8..ef385aeb10 100644
--- 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_pow.java
+++ 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/Math_pow.java
@@ -27,7 +27,7 @@ import org.apache.jena.sparql.ARQInternalErrorException;
 import org.apache.jena.sparql.expr.NodeValue;
 import org.apache.jena.sparql.expr.nodevalue.XSDFuncOp;
 import org.apache.jena.sparql.function.FunctionBase2;
-import org.apache.jena.sparql.function.MathLimits;
+import org.apache.jena.sparql.SparqlLimits;
 
 // math:pow($x as xs:double?, $y as xs:numeric) as xs:double?
 //    except pow(integer,+ve integer) is an integer 
@@ -40,7 +40,7 @@ public class Math_pow extends FunctionBase2 {
                 BigInteger x = v1.getInteger();
                 int y = v2.getInteger().intValue();
                 if (y >= 0) {
-                    MathLimits.preValidateExponentCalculation(x, 
v2.getInteger());
+                    SparqlLimits.preValidateExponentCalculation(x, 
v2.getInteger());
                     return NodeValue.makeInteger(x.pow(y));
                 }
                 // Anything else -> double
@@ -77,7 +77,7 @@ public class Math_pow extends FunctionBase2 {
 
                 // If we get this far pre-validate that calculating the power 
won't require too many digits and if not
                 // actually calculate
-                MathLimits.preValidateExponentCalculation(d1, d2);
+                SparqlLimits.preValidateExponentCalculation(d1, d2);
                 return NodeValue.makeDouble(Math.pow(v1.getDouble(), 
v2.getDouble()));
             default:
                 throw new ARQInternalErrorException("Unrecognized numeric 
operation : " + v1);
diff --git 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/cartesian.java
 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/cartesian.java
index e63cb4f366..bd2fc22c19 100644
--- 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/cartesian.java
+++ 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/cartesian.java
@@ -29,7 +29,7 @@ import org.apache.jena.sparql.expr.ExprEvalException;
 import org.apache.jena.sparql.expr.ExprList;
 import org.apache.jena.sparql.expr.NodeValue;
 import org.apache.jena.sparql.function.FunctionBase;
-import org.apache.jena.sparql.function.MathLimits;
+import org.apache.jena.sparql.SparqlLimits;
 
 public class cartesian extends FunctionBase {
 
@@ -43,8 +43,8 @@ public class cartesian extends FunctionBase {
             double dX = args.get(0).getDouble() - args.get(2).getDouble();
             double dY = args.get(1).getDouble() - args.get(3).getDouble();
 
-            MathLimits.preValidateExponentCalculation(dX, 2);
-            MathLimits.preValidateExponentCalculation(dY, 2);
+            SparqlLimits.preValidateExponentCalculation(dX, 2);
+            SparqlLimits.preValidateExponentCalculation(dY, 2);
             return NodeValue.makeDouble(Math.sqrt(Math.pow(dX, 2) + 
Math.pow(dY, 2)));
         }
         case 6: {
@@ -52,9 +52,9 @@ public class cartesian extends FunctionBase {
             double dY = args.get(1).getDouble() - args.get(4).getDouble();
             double dZ = args.get(2).getDouble() - args.get(5).getDouble();
 
-            MathLimits.preValidateExponentCalculation(dX, 2);
-            MathLimits.preValidateExponentCalculation(dY, 2);
-            MathLimits.preValidateExponentCalculation(dZ, 2);
+            SparqlLimits.preValidateExponentCalculation(dX, 2);
+            SparqlLimits.preValidateExponentCalculation(dY, 2);
+            SparqlLimits.preValidateExponentCalculation(dZ, 2);
             return NodeValue.makeDouble(Math.sqrt(Math.pow(dX, 2) + 
Math.pow(dY, 2) + Math.pow(dZ, 2)));
         }
         default:
diff --git 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/cube.java
 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/cube.java
index 136afa9d7d..0a4c9dd92e 100644
--- 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/cube.java
+++ 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/cube.java
@@ -27,7 +27,7 @@ import org.apache.jena.sparql.ARQInternalErrorException;
 import org.apache.jena.sparql.expr.NodeValue;
 import org.apache.jena.sparql.expr.nodevalue.XSDFuncOp;
 import org.apache.jena.sparql.function.FunctionBase1;
-import org.apache.jena.sparql.function.MathLimits;
+import org.apache.jena.sparql.SparqlLimits;
 
 public class cube extends FunctionBase1 {
 
@@ -37,15 +37,15 @@ public class cube extends FunctionBase1 {
         {
             case OP_INTEGER:
                 BigInteger i = v.getInteger();
-                MathLimits.preValidateExponentCalculation(i, 
BigInteger.valueOf(3));
+                SparqlLimits.preValidateExponentCalculation(i, 
BigInteger.valueOf(3));
                 return NodeValue.makeInteger( i.pow(3) );
             case OP_DECIMAL:
                 double dec = v.getDecimal().doubleValue();
-                MathLimits.preValidateExponentCalculation(dec, 3d);
+                SparqlLimits.preValidateExponentCalculation(dec, 3d);
                 return NodeValue.makeDecimal( Math.pow(dec, 3d));
             case OP_FLOAT:
             case OP_DOUBLE:
-                MathLimits.preValidateExponentCalculation(v.getDouble(), 3d);
+                SparqlLimits.preValidateExponentCalculation(v.getDouble(), 3d);
                 return NodeValue.makeDouble( Math.pow(v.getDouble(), 3d) );
             default:
                 throw new ARQInternalErrorException("Unrecognized numeric 
operation : "+v);
diff --git 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/factorial.java
 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/factorial.java
index 17935d498b..9de244df2b 100644
--- 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/factorial.java
+++ 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/factorial.java
@@ -26,7 +26,7 @@ import java.math.BigInteger;
 import org.apache.jena.sparql.expr.ExprEvalException;
 import org.apache.jena.sparql.expr.NodeValue;
 import org.apache.jena.sparql.function.FunctionBase1;
-import org.apache.jena.sparql.function.MathLimits;
+import org.apache.jena.sparql.SparqlLimits;
 
 public class factorial extends FunctionBase1 {
 
@@ -44,7 +44,7 @@ public class factorial extends FunctionBase1 {
         case 1:
             BigInteger res = i.add(BigInteger.ZERO);
             i = i.subtract(BigInteger.ONE);
-            MathLimits.preValidateFactorial(i);
+            SparqlLimits.preValidateFactorial(i);
             while (i.compareTo(BigInteger.ZERO) != 0) {
                 res = res.multiply(i);
                 i = i.subtract(BigInteger.ONE);
diff --git 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/pow.java
 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/pow.java
index f56d0415b1..f68a894f8f 100644
--- 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/pow.java
+++ 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/pow.java
@@ -25,7 +25,7 @@ import org.apache.jena.sparql.ARQInternalErrorException;
 import org.apache.jena.sparql.expr.NodeValue;
 import org.apache.jena.sparql.expr.nodevalue.XSDFuncOp;
 import org.apache.jena.sparql.function.FunctionBase2;
-import org.apache.jena.sparql.function.MathLimits;
+import org.apache.jena.sparql.SparqlLimits;
 import org.apache.jena.sparql.function.library.Math_pow;
 
 public class pow extends FunctionBase2 {
@@ -38,7 +38,7 @@ public class pow extends FunctionBase2 {
         {
             case OP_DECIMAL:
                 double dec = v1.getDecimal().doubleValue();
-                MathLimits.preValidateExponentCalculation(dec, v2.getDouble());
+                SparqlLimits.preValidateExponentCalculation(dec, 
v2.getDouble());
                 return NodeValue.makeDecimal( Math.pow(dec, v2.getDouble()));
             case OP_INTEGER:
             case OP_FLOAT:
diff --git 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/pythagoras.java
 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/pythagoras.java
index 044419ed9f..d9899d61ea 100644
--- 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/pythagoras.java
+++ 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/pythagoras.java
@@ -23,7 +23,7 @@ package org.apache.jena.sparql.function.library.leviathan;
 
 import org.apache.jena.sparql.expr.NodeValue;
 import org.apache.jena.sparql.function.FunctionBase2;
-import org.apache.jena.sparql.function.MathLimits;
+import org.apache.jena.sparql.SparqlLimits;
 
 public class pythagoras extends FunctionBase2 {
 
@@ -32,8 +32,8 @@ public class pythagoras extends FunctionBase2 {
         double a = v1.getDouble();
         double b = v2.getDouble();
 
-        MathLimits.preValidateExponentCalculation(a, 2);
-        MathLimits.preValidateExponentCalculation(b, 2);
+        SparqlLimits.preValidateExponentCalculation(a, 2);
+        SparqlLimits.preValidateExponentCalculation(b, 2);
         return NodeValue.makeDouble(Math.sqrt(Math.pow(a, 2) + Math.pow(b, 
2)));
     }
 
diff --git 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/root.java
 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/root.java
index 71636461f6..c57ca71780 100644
--- 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/root.java
+++ 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/root.java
@@ -23,7 +23,7 @@ package org.apache.jena.sparql.function.library.leviathan;
 
 import org.apache.jena.sparql.expr.NodeValue;
 import org.apache.jena.sparql.function.FunctionBase2;
-import org.apache.jena.sparql.function.MathLimits;
+import org.apache.jena.sparql.SparqlLimits;
 
 public class root extends FunctionBase2 {
 
@@ -32,7 +32,7 @@ public class root extends FunctionBase2 {
         double value = v1.getDouble();
         double root = v2.getDouble();
 
-        MathLimits.preValidateExponentCalculation(value, 1d / root);
+        SparqlLimits.preValidateExponentCalculation(value, 1d / root);
         return NodeValue.makeDouble(Math.pow(value, 1d / root));
     }
 
diff --git 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/sq.java
 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/sq.java
index d318869112..4a0bcf3ac2 100644
--- 
a/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/sq.java
+++ 
b/jena-arq/src/main/java/org/apache/jena/sparql/function/library/leviathan/sq.java
@@ -27,7 +27,7 @@ import org.apache.jena.sparql.ARQInternalErrorException;
 import org.apache.jena.sparql.expr.NodeValue;
 import org.apache.jena.sparql.expr.nodevalue.XSDFuncOp;
 import org.apache.jena.sparql.function.FunctionBase1;
-import org.apache.jena.sparql.function.MathLimits;
+import org.apache.jena.sparql.SparqlLimits;
 
 public class sq extends FunctionBase1 {
 
@@ -37,15 +37,15 @@ public class sq extends FunctionBase1 {
         {
             case OP_INTEGER:
                 BigInteger i = v.getInteger();
-                MathLimits.preValidateExponentCalculation(i, 
BigInteger.valueOf(2));
+                SparqlLimits.preValidateExponentCalculation(i, 
BigInteger.valueOf(2));
                 return NodeValue.makeInteger( i.pow(2) );
             case OP_DECIMAL:
                 double dec = v.getDecimal().doubleValue();
-                MathLimits.preValidateExponentCalculation(dec, 2d);
+                SparqlLimits.preValidateExponentCalculation(dec, 2d);
                 return NodeValue.makeDecimal( Math.pow(dec, 2d));
             case OP_FLOAT:
             case OP_DOUBLE:
-                MathLimits.preValidateExponentCalculation(v.getDouble(), 2d);
+                SparqlLimits.preValidateExponentCalculation(v.getDouble(), 2d);
                 return NodeValue.makeDouble( Math.pow(v.getDouble(), 2d) );
             default:
                 throw new ARQInternalErrorException("Unrecognized numeric 
operation : "+v);   
diff --git 
a/jena-arq/src/main/java/org/apache/jena/sparql/path/PathCompiler.java 
b/jena-arq/src/main/java/org/apache/jena/sparql/path/PathCompiler.java
index 4d2e31318a..94e35b89e9 100644
--- a/jena-arq/src/main/java/org/apache/jena/sparql/path/PathCompiler.java
+++ b/jena-arq/src/main/java/org/apache/jena/sparql/path/PathCompiler.java
@@ -25,6 +25,7 @@ import org.apache.jena.graph.Node;
 import org.apache.jena.graph.Triple;
 import org.apache.jena.sparql.ARQConstants;
 import org.apache.jena.sparql.ARQException;
+import org.apache.jena.sparql.SparqlLimits;
 import org.apache.jena.sparql.algebra.optimize.TransformPathFlattenAlgebra;
 import org.apache.jena.sparql.algebra.optimize.TransformPathFlatten;
 import org.apache.jena.sparql.core.PathBlock;
@@ -33,20 +34,6 @@ import org.apache.jena.sparql.core.Var;
 import org.apache.jena.sparql.core.VarAlloc;
 
 public class PathCompiler {
-    /**
-     * Default maximum length value used for the {@link 
#MAX_LENGTH_PATH_FOR_REDUCTION} control
-     */
-    public static final int DEFAULT_MAX_LENGTH = 5;
-    /**
-     * Specifies the maximum length (inclusive) of a path that will be reduced 
by expanding it into individual
-     * invocations of the path expression linked by intermediate variables.  
Defaults to {@value #DEFAULT_MAX_LENGTH}.
-     * <p>
-     * This control prevents a query using a path like {@code :x :p{N} :y} 
with a large value of {@code N} being
-     * expanded into a massive algebra tree that yields no performance 
benefits.
-     * </p>
-     * @see #isReducibleLength(long)
-     */
-    public static int MAX_LENGTH_PATH_FOR_REDUCTION = DEFAULT_MAX_LENGTH;
 
     // Convert to work on OpPath.
     // Need pre (and post) BGPs.
@@ -141,7 +128,7 @@ public class PathCompiler {
 
         if ( path instanceof P_FixedLength pFixedLen ) {
             long N = pFixedLen.getCount();
-            if (isReducibleLength(N)) {
+            if (SparqlLimits.isReducibleLength(N)) {
                 // Don't do {0}
                 // Also if the path is too long the reduction won't generate 
any performance benefits
                 reduceFixedLength(x, varAlloc, startNode, endNode, N, 
pFixedLen.getSubPath());
@@ -152,7 +139,7 @@ public class PathCompiler {
         if ( path instanceof P_Mod pMod ) {
             if ( pMod.isFixedLength() && pMod.getFixedLength() > 0 ) {
                 long N = pMod.getFixedLength();
-                if (isReducibleLength(N)) {
+                if (SparqlLimits.isReducibleLength(N)) {
                     reduceFixedLength(x, varAlloc, startNode, endNode, N, 
pMod.getSubPath());
                     return;
                 }
@@ -202,21 +189,6 @@ public class PathCompiler {
         x.add(new TriplePath(startNode, path, endNode));
     }
 
-    /**
-     * Checks whether a given length of path is considered reducible
-     * <p>
-     * Only paths that are non-zero length and less than, or equal to, the 
configured
-     * {@link #MAX_LENGTH_PATH_FOR_REDUCTION} (default {@value 
#DEFAULT_MAX_LENGTH}) are considered reducible.  Anything
-     * else is left as-is as either reduction would change semantics (for 
zero-length paths), or could lead to very
-     * large algebra tree which would negatively impact performance.
-     * </p>
-     * @param N Path length
-     * @return True if reducible, false otherwise
-     */
-    public static boolean isReducibleLength(long N) {
-        return N > 0 && N <= MAX_LENGTH_PATH_FOR_REDUCTION;
-    }
-
     /**
      * Reduces a fixed length path by expanding the {@code n} steps into 
individual path invocations with intermediate
      * variables.
@@ -226,6 +198,7 @@ public class PathCompiler {
      * @param endNode       End node
      * @param n             Fixed path length
      * @param subPath       Sub path to use in each expanded step
+     * @see SparqlLimits#isReducibleLength(long)
      */
     private static void reduceFixedLength(PathBlock x, VarAlloc varAlloc, Node 
startNode, Node endNode, long n,
                                           Path subPath) {
diff --git 
a/jena-arq/src/main/java/org/apache/jena/sparql/pfunction/library/strSplit.java 
b/jena-arq/src/main/java/org/apache/jena/sparql/pfunction/library/strSplit.java
index d123dbb6c1..089bd86d26 100644
--- 
a/jena-arq/src/main/java/org/apache/jena/sparql/pfunction/library/strSplit.java
+++ 
b/jena-arq/src/main/java/org/apache/jena/sparql/pfunction/library/strSplit.java
@@ -32,13 +32,13 @@ import org.apache.jena.graph.Node ;
 import org.apache.jena.graph.NodeFactory ;
 import org.apache.jena.query.QueryBuildException;
 import org.apache.jena.rdf.model.impl.Util ;
+import org.apache.jena.sparql.SparqlLimits;
 import org.apache.jena.sparql.core.Var ;
 import org.apache.jena.sparql.engine.ExecutionContext ;
 import org.apache.jena.sparql.engine.QueryIterator ;
 import org.apache.jena.sparql.engine.binding.Binding ;
 import org.apache.jena.sparql.engine.binding.BindingFactory ;
 import org.apache.jena.sparql.engine.iterator.QueryIterPlainWrapper ;
-import org.apache.jena.sparql.expr.ExprEvalException;
 import org.apache.jena.sparql.expr.RegexEngine;
 import org.apache.jena.sparql.pfunction.PFuncSimpleAndList ;
 import org.apache.jena.sparql.pfunction.PropFuncArg ;
@@ -77,7 +77,7 @@ public class strSplit extends PFuncSimpleAndList
 
         // StrUtils will also trim whitespace
         List<String> tokens;
-        if (RegexEngine.MAX_REGEX_EVALUATION_TIME > 0) {
+        if (SparqlLimits.MAX_REGEX_EVALUATION_TIME > 0) {
             Pattern pattern = Pattern.compile(regex);
             tokens = Arrays.stream(pattern.split(RegexEngine.timeBounded(s), 
0))
                            .map(String::trim)
diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/TC_ARQ.java 
b/jena-arq/src/test/java/org/apache/jena/sparql/TC_ARQ.java
index 6b28a0a5bb..c947fcf67e 100644
--- a/jena-arq/src/test/java/org/apache/jena/sparql/TC_ARQ.java
+++ b/jena-arq/src/test/java/org/apache/jena/sparql/TC_ARQ.java
@@ -85,6 +85,9 @@ import org.apache.jena.sparql.syntax.TS_Syntax;
     , TS_Update.class
     , TS_SparqlLib.class
 
+    // SPARQL Limits
+    , TestSparqlLimits.class
+
     // Outside org.apache.jena.sparql
     , TS_Query.class
 
diff --git 
a/jena-arq/src/test/java/org/apache/jena/sparql/function/library/TestMathLimits.java
 b/jena-arq/src/test/java/org/apache/jena/sparql/TestSparqlLimits.java
similarity index 84%
rename from 
jena-arq/src/test/java/org/apache/jena/sparql/function/library/TestMathLimits.java
rename to jena-arq/src/test/java/org/apache/jena/sparql/TestSparqlLimits.java
index c33f02eb1d..6a5cdd7d8c 100644
--- 
a/jena-arq/src/test/java/org/apache/jena/sparql/function/library/TestMathLimits.java
+++ b/jena-arq/src/test/java/org/apache/jena/sparql/TestSparqlLimits.java
@@ -19,10 +19,9 @@
  *   SPDX-License-Identifier: Apache-2.0
  */
 
-package org.apache.jena.sparql.function.library;
+package org.apache.jena.sparql;
 
 import org.apache.jena.sparql.expr.ExprEvalException;
-import org.apache.jena.sparql.function.MathLimits;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -32,7 +31,7 @@ import java.util.stream.Stream;
 
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-public class TestMathLimits {
+public class TestSparqlLimits {
 
     public static Stream<Arguments> bigIntegerExponents() {
         return Stream.of(Arguments.of(BigInteger.valueOf(2), 
BigInteger.valueOf(16), true),
@@ -45,9 +44,9 @@ public class TestMathLimits {
     @MethodSource("bigIntegerExponents")
     public void 
givenBigIntegers_whenPreValidatingExponent_thenAsExpected(BigInteger a, 
BigInteger b, boolean valid) {
         if (valid) {
-            MathLimits.preValidateExponentCalculation(a, b);
+            SparqlLimits.preValidateExponentCalculation(a, b);
         } else {
-            assertThrows(ExprEvalException.class, () -> 
MathLimits.preValidateExponentCalculation(a, b));
+            assertThrows(ExprEvalException.class, () -> 
SparqlLimits.preValidateExponentCalculation(a, b));
         }
     }
 
@@ -61,9 +60,9 @@ public class TestMathLimits {
     @MethodSource("factorials")
     public void 
givenFactorialInputs_whenPreValidating_thenAsExpected(BigInteger n, boolean 
valid) {
         if (valid) {
-            MathLimits.preValidateFactorial(n);
+            SparqlLimits.preValidateFactorial(n);
         } else {
-            assertThrows(ExprEvalException.class, () -> 
MathLimits.preValidateFactorial(n));
+            assertThrows(ExprEvalException.class, () -> 
SparqlLimits.preValidateFactorial(n));
         }
     }
 }
diff --git 
a/jena-arq/src/test/java/org/apache/jena/sparql/algebra/optimize/TestTransformPathFlatten.java
 
b/jena-arq/src/test/java/org/apache/jena/sparql/algebra/optimize/TestTransformPathFlatten.java
index daa0fe29d8..6b6a63f538 100644
--- 
a/jena-arq/src/test/java/org/apache/jena/sparql/algebra/optimize/TestTransformPathFlatten.java
+++ 
b/jena-arq/src/test/java/org/apache/jena/sparql/algebra/optimize/TestTransformPathFlatten.java
@@ -26,6 +26,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
 
+import org.apache.jena.sparql.SparqlLimits;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -501,11 +502,11 @@ public class TestTransformPathFlatten {
         try {
             // Reconfiguring the maximum permitted path length for reduction 
should prevent this query from being
             // optimised
-            PathCompiler.MAX_LENGTH_PATH_FOR_REDUCTION = 3;
+            SparqlLimits.MAX_LENGTH_PATH_FOR_REDUCTION = 3;
             Op op1 = path("?x", ":p{5}", ":T1");
             testDefaultTransform(op1, null);
         } finally {
-            PathCompiler.MAX_LENGTH_PATH_FOR_REDUCTION = 
PathCompiler.DEFAULT_MAX_LENGTH;
+            SparqlLimits.MAX_LENGTH_PATH_FOR_REDUCTION = 
SparqlLimits.DEFAULT_MAX_PATH_REDUCTION_LENGTH;
         }
     }
 
@@ -513,11 +514,11 @@ public class TestTransformPathFlatten {
         try {
             // Reconfiguring the maximum permitted path length for reduction 
should prevent this query from being
             // optimised
-            PathCompiler.MAX_LENGTH_PATH_FOR_REDUCTION = 3;
+            SparqlLimits.MAX_LENGTH_PATH_FOR_REDUCTION = 3;
             Op op1 = path("?x", ":p{5}", ":T1");
             testAlgebraTransform(op1, null);
         } finally {
-            PathCompiler.MAX_LENGTH_PATH_FOR_REDUCTION = 
PathCompiler.DEFAULT_MAX_LENGTH;
+            SparqlLimits.MAX_LENGTH_PATH_FOR_REDUCTION = 
SparqlLimits.DEFAULT_MAX_PATH_REDUCTION_LENGTH;
         }
     }
 
diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestRegex.java 
b/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestRegex.java
index 2412d1b1bf..66622c6c20 100644
--- a/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestRegex.java
+++ b/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestRegex.java
@@ -27,6 +27,7 @@ import static org.junit.jupiter.api.Assertions.fail;
 import java.util.List;
 import java.util.stream.Stream;
 
+import org.apache.jena.sparql.SparqlLimits;
 import org.apache.logging.log4j.util.Strings;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -44,6 +45,11 @@ import org.apache.jena.sparql.engine.binding.BindingFactory;
 public class TestRegex
 {
 
+    /**
+     * Example data used for some early catastrophic backtracking testing, 
unfortunately this example exhibited very
+     * different runtime characteristics on the different regex engines making 
it unusable as a reliable test case
+     */
+    @SuppressWarnings("unused")
     protected static final String ALPHABET_CSV = 
"a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,z,";
 
     private static Stream<Arguments> provideArgs() {
@@ -134,30 +140,30 @@ public class TestRegex
 
     @ParameterizedTest(name = "{1}")
     @MethodSource("backtrackingRegex")
-    public void 
givenBacktrackingRegex_whenEvaluatingRegexWithoutTimeLimit_thenEventuallyCompletes(String
 input, String pattern, String flags, boolean shouldMatch) {
+    public void 
backtrackingRegexWithTimeLimitDisabledEventuallyCompletes(String input, String 
pattern, String flags, boolean shouldMatch) {
         // Given, When and Then
-        long existingMax = RegexEngine.MAX_REGEX_EVALUATION_TIME;
+        long existingMax = SparqlLimits.MAX_REGEX_EVALUATION_TIME;
         try {
-            RegexEngine.MAX_REGEX_EVALUATION_TIME = -1;
+            SparqlLimits.MAX_REGEX_EVALUATION_TIME = -1;
             regexTest(input, pattern, flags, shouldMatch);
         } finally {
-            RegexEngine.MAX_REGEX_EVALUATION_TIME = existingMax;
+            SparqlLimits.MAX_REGEX_EVALUATION_TIME = existingMax;
         }
     }
 
     @ParameterizedTest(name = "{1}")
     @MethodSource("backtrackingRegex")
-    public void 
givenBacktrackingRegex_whenEvaluatingRegexWithTimeLimit_thenFails(String input, 
String pattern, String flags, boolean shouldMatch) {
+    public void backtrackingRegexWithTimeLimitFails(String input, String 
pattern, String flags, boolean shouldMatch) {
         // Given, When and Then
-        long existingMax = RegexEngine.MAX_REGEX_EVALUATION_TIME;
+        long existingMax = SparqlLimits.MAX_REGEX_EVALUATION_TIME;
         try {
             // Intentionally minimal evaluation time so should fail near 
immediately, while we could set a more
             // realistic limit for the test the reality is that the different 
regex engines evaluate at different speed
             // so it's hard to pick a limit that reliably fails other than a 
trivially small one
-            RegexEngine.MAX_REGEX_EVALUATION_TIME = 1;
+            SparqlLimits.MAX_REGEX_EVALUATION_TIME = 1;
             assertThrows(ExprEvalException.class, () -> regexTest(input, 
pattern, flags, shouldMatch));
         } finally {
-            RegexEngine.MAX_REGEX_EVALUATION_TIME = existingMax;
+            SparqlLimits.MAX_REGEX_EVALUATION_TIME = existingMax;
         }
     }
 }
diff --git 
a/jena-arq/src/test/java/org/apache/jena/sparql/function/library/TS_LibraryFunctions.java
 
b/jena-arq/src/test/java/org/apache/jena/sparql/function/library/TS_LibraryFunctions.java
index b6eb8c7a12..6561dc23ae 100644
--- 
a/jena-arq/src/test/java/org/apache/jena/sparql/function/library/TS_LibraryFunctions.java
+++ 
b/jena-arq/src/test/java/org/apache/jena/sparql/function/library/TS_LibraryFunctions.java
@@ -21,6 +21,7 @@
 
 package org.apache.jena.sparql.function.library;
 
+import org.apache.jena.sparql.TestSparqlLimits;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.platform.suite.api.SelectClasses;
@@ -38,7 +39,6 @@ import org.apache.jena.sparql.expr.NodeValue;
     , TestFnFunctionsOther.class
     , TestFnFunctionsFormat.class
     , TestFnFunctionsCollation.class
-    , TestMathLimits.class
 })
 public class TS_LibraryFunctions {
     // Expected warnings off.
diff --git 
a/jena-arq/src/test/java/org/apache/jena/sparql/pfunction/library/TestStrSplit.java
 
b/jena-arq/src/test/java/org/apache/jena/sparql/pfunction/library/TestStrSplit.java
index 5e0b299acb..26c41b7e7d 100644
--- 
a/jena-arq/src/test/java/org/apache/jena/sparql/pfunction/library/TestStrSplit.java
+++ 
b/jena-arq/src/test/java/org/apache/jena/sparql/pfunction/library/TestStrSplit.java
@@ -28,8 +28,8 @@ import java.util.stream.Stream;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.Strings;
 import org.apache.jena.query.*;
+import org.apache.jena.sparql.SparqlLimits;
 import org.apache.jena.sparql.expr.ExprEvalException;
-import org.apache.jena.sparql.expr.RegexEngine;
 import org.junit.jupiter.api.Test;
 
 import org.apache.jena.graph.Node;
@@ -130,10 +130,10 @@ public class TestStrSplit {
 
     @ParameterizedTest(name = "{1}")
     @MethodSource("slowSplits")
-    public void givenSlowRegex_whenSplittingWithTimeLimit_thenFails(String 
data, String pattern, int expectedResultCount) {
-        long existingLimit = RegexEngine.MAX_REGEX_EVALUATION_TIME;
+    public void slowRegexWithTimeLimitShouldFail(String data, String pattern, 
int expectedResultCount) {
+        long existingLimit = SparqlLimits.MAX_REGEX_EVALUATION_TIME;
         try {
-            RegexEngine.MAX_REGEX_EVALUATION_TIME = 1;
+            SparqlLimits.MAX_REGEX_EVALUATION_TIME = 1;
             query("SELECT ?x WHERE { ?x apf:strSplit ('" + data + "' '" + 
pattern + "') }");
             long start = System.currentTimeMillis();
             ExprEvalException e = assertThrows(ExprEvalException.class, () -> 
qe.execSelect().hasNext());
@@ -141,23 +141,23 @@ public class TestStrSplit {
             assertTrue(elapsed <= 250, "Elapsed time was " + elapsed);
             assertTrue(Strings.CI.contains(e.getMessage(), "time limit 
exceeded"));
         } finally {
-            RegexEngine.MAX_REGEX_EVALUATION_TIME = existingLimit;
+            SparqlLimits.MAX_REGEX_EVALUATION_TIME = existingLimit;
         }
     }
 
     @ParameterizedTest(name = "{1}")
     @MethodSource("slowSplits")
-    public void 
givenSlowRegex_whenSplittingWithNoTimeLimit_thenEventuallySucceeds(String data, 
String pattern, int expectedResultCount) {
-        long existingLimit = RegexEngine.MAX_REGEX_EVALUATION_TIME;
+    public void slowRegexWithDisabledTimeLimitEventuallySucceeds(String data, 
String pattern, int expectedResultCount) {
+        long existingLimit = SparqlLimits.MAX_REGEX_EVALUATION_TIME;
         try {
             // Given
             query("SELECT ?x WHERE { ?x apf:strSplit ('" + data + "' '" + 
pattern + "') }");
 
             // When and Then
-            RegexEngine.MAX_REGEX_EVALUATION_TIME = -1;
+            SparqlLimits.MAX_REGEX_EVALUATION_TIME = -1;
             assertEquals(expectedResultCount, 
ResultSetFormatter.consume(qe.execSelect()));
         } finally {
-            RegexEngine.MAX_REGEX_EVALUATION_TIME = existingLimit;
+            SparqlLimits.MAX_REGEX_EVALUATION_TIME = existingLimit;
         }
     }
 

Reply via email to