Author: fanningpj
Date: Fri Jul 17 21:00:45 2026
New Revision: 1936284

Log:
more work on making num lens configurable

Modified:
   xmlbeans/trunk/src/main/java/org/apache/xmlbeans/XmlCalendar.java
   xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/inst2xsd/Inst2Xsd.java
   
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/schema/SchemaTypeLoaderBase.java
   xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/tool/PrettyPrinter.java
   xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/util/MathUtil.java
   
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/util/XsTypeConverter.java
   
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/validator/Validator.java
   
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/values/JavaDoubleHolder.java
   
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/values/JavaDoubleHolderEx.java
   
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/values/JavaFloatHolder.java
   
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/values/JavaFloatHolderEx.java
   xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/xpath/XPathFactory.java
   xmlbeans/trunk/src/main/java/org/apache/xmlbeans/soap/SOAPArrayType.java
   xmlbeans/trunk/src/test/java/misc/checkin/XsTypeConverterTest.java

Modified: xmlbeans/trunk/src/main/java/org/apache/xmlbeans/XmlCalendar.java
==============================================================================
--- xmlbeans/trunk/src/main/java/org/apache/xmlbeans/XmlCalendar.java   Fri Jul 
17 20:23:20 2026        (r1936283)
+++ xmlbeans/trunk/src/main/java/org/apache/xmlbeans/XmlCalendar.java   Fri Jul 
17 21:00:45 2026        (r1936284)
@@ -274,7 +274,7 @@ public class XmlCalendar extends Gregori
             {
                 String yearstring = 
SystemProperties.getProperty("user.defaultyear");
                 if (yearstring != null)
-                    defaultYear = MathUtil.parseAsInteger(yearstring);
+                    defaultYear = MathUtil.parseAsInt(yearstring);
                 else
                     defaultYear = DEFAULT_DEFAULT_YEAR;
             }

Modified: 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/inst2xsd/Inst2Xsd.java
==============================================================================
--- 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/inst2xsd/Inst2Xsd.java    
    Fri Jul 17 20:23:20 2026        (r1936283)
+++ 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/inst2xsd/Inst2Xsd.java    
    Fri Jul 17 21:00:45 2026        (r1936284)
@@ -150,7 +150,7 @@ public class Inst2Xsd
         {
             try
             {
-                int intVal = MathUtil.parseAsInteger(enumerations);
+                int intVal = MathUtil.parseAsInt(enumerations);
                 inst2XsdOptions.setUseEnumerations(intVal);
             }
             catch (NumberFormatException e)

Modified: 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/schema/SchemaTypeLoaderBase.java
==============================================================================
--- 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/schema/SchemaTypeLoaderBase.java
      Fri Jul 17 20:23:20 2026        (r1936283)
+++ 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/schema/SchemaTypeLoaderBase.java
      Fri Jul 17 21:00:45 2026        (r1936284)
@@ -450,7 +450,7 @@ public abstract class SchemaTypeLoaderBa
                     if (curType == null) {
                         throw new IllegalArgumentException();
                     } else {
-                        int index = 
MathUtil.parseAsInteger(part.substring(offset));
+                        int index = 
MathUtil.parseAsInt(part.substring(offset));
 
                         if (curType.getSimpleVariety() != SchemaType.UNION) {
                             return null;

Modified: 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/tool/PrettyPrinter.java
==============================================================================
--- 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/tool/PrettyPrinter.java   
    Fri Jul 17 20:23:20 2026        (r1936283)
+++ 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/tool/PrettyPrinter.java   
    Fri Jul 17 21:00:45 2026        (r1936284)
@@ -93,7 +93,7 @@ public class PrettyPrinter
         if (indentStr == null)
             indent = DEFAULT_INDENT;
         else
-            indent = MathUtil.parseAsInteger(indentStr);
+            indent = MathUtil.parseAsInt(indentStr);
         
         File[] files = cl.getFiles();
         

Modified: 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/util/MathUtil.java
==============================================================================
--- xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/util/MathUtil.java    
Fri Jul 17 20:23:20 2026        (r1936283)
+++ xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/util/MathUtil.java    
Fri Jul 17 21:00:45 2026        (r1936284)
@@ -106,41 +106,65 @@ public class MathUtil {
      * @throws IllegalArgumentException if string is too long
      * @throws NullPointerException if string is null
      */
-    public static Float parseAsFloat(String s) {
+    public static float parseAsFloat(String s) {
+        return parseAsFloat(s, DEFAULT_MAX_NUMBER_CHARS);
+    }
+
+    /**
+     * @param s string to parse
+     * @param maxNumberOfChars maximum number of characters allowed in the 
string
+     * @return valid float
+     * @throws NumberFormatException if parse fails
+     * @throws IllegalArgumentException if string is too long
+     * @throws NullPointerException if string is null
+     */
+    public static float parseAsFloat(String s, int maxNumberOfChars) {
         if (s == null) {
             throw new NullPointerException("Cannot parse null as Float");
         }
-        if (s.length() > DEFAULT_MAX_NUMBER_CHARS) {
-            throw new IllegalArgumentException("Number has more than " + 
DEFAULT_MAX_NUMBER_CHARS + " characters");
+        if (s.length() > maxNumberOfChars) {
+            throw new IllegalArgumentException("Number has more than " + 
maxNumberOfChars + " characters");
         }
         return Float.parseFloat(s);
     }
 
     /**
      * @param s string to parse
-     * @return valid Float
+     * @return valid float
      * @throws NumberFormatException if parse fails
      * @throws IllegalArgumentException if string is too long
      * @throws NullPointerException if string is null
      */
-    public static Double parseAsDouble(String s) {
+    public static double parseAsDouble(String s) {
+        return parseAsDouble(s, DEFAULT_MAX_NUMBER_CHARS);
+    }
+
+    /**
+     * @param s string to parse
+     * @param maxNumberOfChars maximum number of characters allowed in the 
string
+     * @return valid float
+     * @throws NumberFormatException if parse fails
+     * @throws IllegalArgumentException if string is too long
+     * @throws NullPointerException if string is null
+     */
+    public static double parseAsDouble(String s, int maxNumberOfChars) {
         if (s == null) {
             throw new NullPointerException("Cannot parse null as Double");
         }
-        if (s.length() > DEFAULT_MAX_NUMBER_CHARS) {
-            throw new IllegalArgumentException("Number has more than " + 
DEFAULT_MAX_NUMBER_CHARS + " characters");
+        if (s.length() > maxNumberOfChars) {
+            throw new IllegalArgumentException("Number has more than " + 
maxNumberOfChars + " characters");
         }
         return Double.parseDouble(s);
     }
 
     /**
      * @param s string to parse
-     * @return valid Long
+     * @return valid long
      * @throws NumberFormatException if parse fails
      * @throws IllegalArgumentException if string is too long
      * @throws NullPointerException if string is null
      */
-    public static Long parseAsLong(String s) {
+    public static long parseAsLong(String s) {
         if (s == null) {
             throw new NullPointerException("Cannot parse null as Long");
         }
@@ -152,12 +176,12 @@ public class MathUtil {
 
     /**
      * @param s string to parse
-     * @return valid Integer
+     * @return valid int
      * @throws NumberFormatException if parse fails
      * @throws IllegalArgumentException if string is too long
      * @throws NullPointerException if string is null
      */
-    public static Integer parseAsInteger(String s) {
+    public static int parseAsInt(String s) {
         if (s == null) {
             throw new NullPointerException("Cannot parse null as Integer");
         }

Modified: 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/util/XsTypeConverter.java
==============================================================================
--- 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/util/XsTypeConverter.java 
    Fri Jul 17 20:23:20 2026        (r1936283)
+++ 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/util/XsTypeConverter.java 
    Fri Jul 17 21:00:45 2026        (r1936284)
@@ -76,7 +76,7 @@ public final class XsTypeConverter {
     // ======================== float ========================
     public static float lexFloat(CharSequence cs)
         throws NumberFormatException {
-        return lexFloat(cs, false);
+        return lexFloat(cs, false, XmlOptions.DEFAULT_MAX_NUMBER_CHARS);
     }
 
     /**
@@ -89,11 +89,13 @@ public final class XsTypeConverter {
      *               ({@code f}/{@code F}/{@code d}/{@code D}). When {@code 
false} the
      *               long-standing lenient behaviour applies. Driven by
      *               {@link 
org.apache.xmlbeans.XmlOptions#setLoadStrictFloatingPoint()}.
+     * @param maxNumberOfChars the maximum number of characters allowed in the 
string
      * @return the parsed float
      * @throws NumberFormatException if the value is not a valid xsd:float
      * @since 5.4.0
      */
-    public static float lexFloat(CharSequence cs, boolean strict)
+    public static float lexFloat(CharSequence cs, boolean strict,
+                                 int maxNumberOfChars)
         throws NumberFormatException {
         rejectInvalidNumber(cs);
         final String v = cs.toString();
@@ -116,12 +118,12 @@ public final class XsTypeConverter {
                 throw new NumberFormatException("Invalid char '" + ch + "' in 
float.");
             }
         }
-        return MathUtil.parseAsFloat(v);
+        return MathUtil.parseAsFloat(v, maxNumberOfChars);
     }
 
     public static float lexFloat(CharSequence cs, Collection<XmlError> errors) 
{
         try {
-            return lexFloat(cs);
+            return lexFloat(cs, false, XmlOptions.DEFAULT_MAX_NUMBER_CHARS);
         } catch (NumberFormatException e) {
             String msg = "invalid float: " + cs;
             errors.add(XmlError.forMessage(msg));
@@ -146,7 +148,7 @@ public final class XsTypeConverter {
     // ======================== double ========================
     public static double lexDouble(CharSequence cs)
         throws NumberFormatException {
-        return lexDouble(cs, false);
+        return lexDouble(cs, false,  XmlOptions.DEFAULT_MAX_NUMBER_CHARS);
     }
 
     /**
@@ -159,11 +161,13 @@ public final class XsTypeConverter {
      *               ({@code f}/{@code F}/{@code d}/{@code D}). When {@code 
false} the
      *               long-standing lenient behaviour applies. Driven by
      *               {@link 
org.apache.xmlbeans.XmlOptions#setLoadStrictFloatingPoint()}.
+     * @param maxNumberOfChars the maximum number of characters allowed in the 
string
      * @return the parsed double
      * @throws NumberFormatException if the value is not a valid xsd:double
      * @since 5.4.0
      */
-    public static double lexDouble(CharSequence cs, boolean strict)
+    public static double lexDouble(CharSequence cs, boolean strict,
+                                   int maxNumberOfChars)
         throws NumberFormatException {
         rejectInvalidNumber(cs);
         final String v = cs.toString();
@@ -186,12 +190,12 @@ public final class XsTypeConverter {
                 throw new NumberFormatException("Invalid char '" + ch + "' in 
double.");
             }
         }
-        return MathUtil.parseAsDouble(v);
+        return MathUtil.parseAsDouble(v, maxNumberOfChars);
     }
 
     public static double lexDouble(CharSequence cs, Collection<XmlError> 
errors) {
         try {
-            return lexDouble(cs);
+            return lexDouble(cs, false, XmlOptions.DEFAULT_MAX_NUMBER_CHARS);
         } catch (NumberFormatException e) {
             String msg = "invalid double: " + cs;
             errors.add(XmlError.forMessage(msg));

Modified: 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/validator/Validator.java
==============================================================================
--- 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/validator/Validator.java  
    Fri Jul 17 20:23:20 2026        (r1936283)
+++ 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/validator/Validator.java  
    Fri Jul 17 21:00:45 2026        (r1936284)
@@ -1122,7 +1122,7 @@ public final class Validator
             }
             case SchemaType.BTC_FLOAT: {
                 float f =
-                    JavaFloatHolderEx.validateLexical(value, type, _vc);
+                    JavaFloatHolderEx.validateLexical(value, type, _vc, 
_options.getMaxNumberOfCharsForNumbers());
 
                 if (errorState == _errorState) {
                     JavaFloatHolderEx.validateValue(f, type, _vc);
@@ -1133,7 +1133,7 @@ public final class Validator
             }
             case SchemaType.BTC_DOUBLE: {
                 double d =
-                    JavaDoubleHolderEx.validateLexical(value, type, _vc);
+                    JavaDoubleHolderEx.validateLexical(value, type, _vc, 
_options.getMaxNumberOfCharsForNumbers());
 
                 if (errorState == _errorState) {
                     JavaDoubleHolderEx.validateValue(d, type, _vc);

Modified: 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/values/JavaDoubleHolder.java
==============================================================================
--- 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/values/JavaDoubleHolder.java
  Fri Jul 17 20:23:20 2026        (r1936283)
+++ 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/values/JavaDoubleHolder.java
  Fri Jul 17 21:00:45 2026        (r1936284)
@@ -18,6 +18,7 @@ package org.apache.xmlbeans.impl.values;
 import org.apache.xmlbeans.SchemaType;
 import org.apache.xmlbeans.XmlErrorCodes;
 import org.apache.xmlbeans.XmlObject;
+import org.apache.xmlbeans.XmlOptions;
 import org.apache.xmlbeans.impl.common.ValidationContext;
 import org.apache.xmlbeans.impl.schema.BuiltinSchemaTypeSystem;
 import org.apache.xmlbeans.impl.util.XsTypeConverter;
@@ -61,8 +62,13 @@ public abstract class JavaDoubleHolder e
     }
 
     public static double validateLexical(String v, ValidationContext context, 
boolean strict) {
+        return validateLexical(v, context, strict, 
XmlOptions.DEFAULT_MAX_NUMBER_CHARS);
+    }
+
+    public static double validateLexical(String v, ValidationContext context, 
boolean strict,
+                                         int maxNumberOfCharsForNumbers) {
         try {
-            return XsTypeConverter.lexDouble(v, strict);
+            return XsTypeConverter.lexDouble(v, strict, 
maxNumberOfCharsForNumbers);
         } catch (NumberFormatException e) {
             context.invalid(XmlErrorCodes.DOUBLE, new Object[]{v});
 

Modified: 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/values/JavaDoubleHolderEx.java
==============================================================================
--- 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/values/JavaDoubleHolderEx.java
        Fri Jul 17 20:23:20 2026        (r1936283)
+++ 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/values/JavaDoubleHolderEx.java
        Fri Jul 17 21:00:45 2026        (r1936284)
@@ -18,6 +18,7 @@ package org.apache.xmlbeans.impl.values;
 import org.apache.xmlbeans.SchemaType;
 import org.apache.xmlbeans.XmlErrorCodes;
 import org.apache.xmlbeans.XmlObject;
+import org.apache.xmlbeans.XmlOptions;
 import org.apache.xmlbeans.impl.common.QNameHelper;
 import org.apache.xmlbeans.impl.common.ValidationContext;
 
@@ -42,7 +43,12 @@ public abstract class JavaDoubleHolderEx
     }
 
     public static double validateLexical(String v, SchemaType sType, 
ValidationContext context) {
-        double d = JavaDoubleHolder.validateLexical(v, context);
+        return validateLexical(v, sType, context, 
XmlOptions.DEFAULT_MAX_NUMBER_CHARS);
+    }
+
+    public static double validateLexical(String v, SchemaType sType, 
ValidationContext context,
+                                         int maxNumberOfChars) {
+        double d = JavaDoubleHolder.validateLexical(v, context, false, 
maxNumberOfChars);
 
         if (!sType.matchPatternFacet(v)) {
             context.invalid(XmlErrorCodes.DATATYPE_VALID$PATTERN_VALID,

Modified: 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/values/JavaFloatHolder.java
==============================================================================
--- 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/values/JavaFloatHolder.java
   Fri Jul 17 20:23:20 2026        (r1936283)
+++ 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/values/JavaFloatHolder.java
   Fri Jul 17 21:00:45 2026        (r1936284)
@@ -18,6 +18,7 @@ package org.apache.xmlbeans.impl.values;
 import org.apache.xmlbeans.SchemaType;
 import org.apache.xmlbeans.XmlErrorCodes;
 import org.apache.xmlbeans.XmlObject;
+import org.apache.xmlbeans.XmlOptions;
 import org.apache.xmlbeans.impl.common.ValidationContext;
 import org.apache.xmlbeans.impl.schema.BuiltinSchemaTypeSystem;
 import org.apache.xmlbeans.impl.util.XsTypeConverter;
@@ -61,8 +62,13 @@ public abstract class JavaFloatHolder ex
     }
 
     public static float validateLexical(String v, ValidationContext context, 
boolean strict) {
+        return validateLexical(v, context, strict, 
XmlOptions.DEFAULT_MAX_NUMBER_CHARS);
+    }
+
+    public static float validateLexical(String v, ValidationContext context, 
boolean strict,
+                                        int maxNumberOfChars) {
         try {
-            return XsTypeConverter.lexFloat(v, strict);
+            return XsTypeConverter.lexFloat(v, strict, maxNumberOfChars);
         } catch (NumberFormatException e) {
             context.invalid(XmlErrorCodes.FLOAT, new Object[]{v});
 

Modified: 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/values/JavaFloatHolderEx.java
==============================================================================
--- 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/values/JavaFloatHolderEx.java
 Fri Jul 17 20:23:20 2026        (r1936283)
+++ 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/values/JavaFloatHolderEx.java
 Fri Jul 17 21:00:45 2026        (r1936284)
@@ -18,6 +18,7 @@ package org.apache.xmlbeans.impl.values;
 import org.apache.xmlbeans.SchemaType;
 import org.apache.xmlbeans.XmlErrorCodes;
 import org.apache.xmlbeans.XmlObject;
+import org.apache.xmlbeans.XmlOptions;
 import org.apache.xmlbeans.impl.common.QNameHelper;
 import org.apache.xmlbeans.impl.common.ValidationContext;
 
@@ -42,11 +43,16 @@ public abstract class JavaFloatHolderEx
     }
 
     public static float validateLexical(String v, SchemaType sType, 
ValidationContext context) {
-        float f = JavaFloatHolder.validateLexical(v, context);
+        return validateLexical(v, sType, context, 
XmlOptions.DEFAULT_MAX_NUMBER_CHARS);
+    }
+
+    public static float validateLexical(String v, SchemaType sType, 
ValidationContext context,
+                                        int maxNumberOfChars) {
+        float f = JavaFloatHolder.validateLexical(v, context, false, 
maxNumberOfChars);
 
         if (!sType.matchPatternFacet(v)) {
             context.invalid(XmlErrorCodes.DATATYPE_VALID$PATTERN_VALID,
-                new Object[]{"float", v, QNameHelper.readable(sType)});
+                    new Object[]{"float", v, QNameHelper.readable(sType)});
         }
 
         return f;

Modified: 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/xpath/XPathFactory.java
==============================================================================
--- 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/xpath/XPathFactory.java   
    Fri Jul 17 20:23:20 2026        (r1936283)
+++ 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/impl/xpath/XPathFactory.java   
    Fri Jul 17 21:00:45 2026        (r1936284)
@@ -136,7 +136,7 @@ public class XPathFactory {
         }
 
 
-        int offset = 
MathUtil.parseAsInteger(namespaces.getOrDefault(XPath._NS_BOUNDARY, "0"));
+        int offset = 
MathUtil.parseAsInt(namespaces.getOrDefault(XPath._NS_BOUNDARY, "0"));
         namespaces.remove(XPath._NS_BOUNDARY);
 
         return new SaxonXPath(pathExpr.substring(offset), currentVar, 
namespaces);
@@ -177,7 +177,7 @@ public class XPathFactory {
         } catch (XPath.XPathCompileException e) {
             //don't care if it fails, just care about boundary
         } finally {
-            boundaryVal = 
MathUtil.parseAsInteger(boundary.getOrDefault(XPath._NS_BOUNDARY, "0"));
+            boundaryVal = 
MathUtil.parseAsInt(boundary.getOrDefault(XPath._NS_BOUNDARY, "0"));
         }
 
         return new SaxonXQuery(queryExpr, currentVar, boundaryVal, options);

Modified: 
xmlbeans/trunk/src/main/java/org/apache/xmlbeans/soap/SOAPArrayType.java
==============================================================================
--- xmlbeans/trunk/src/main/java/org/apache/xmlbeans/soap/SOAPArrayType.java    
Fri Jul 17 20:23:20 2026        (r1936283)
+++ xmlbeans/trunk/src/main/java/org/apache/xmlbeans/soap/SOAPArrayType.java    
Fri Jul 17 21:00:45 2026        (r1936284)
@@ -67,7 +67,7 @@ public final class SOAPArrayType {
     private static int collapseDimString(String dimString2) {
         String dimString = XmlWhitespace.collapse(dimString2, 
XmlWhitespace.WS_COLLAPSE);
         try {
-            return ("*".equals(dimString) || dimString.isEmpty()) ? -1 : 
MathUtil.parseAsInteger(dimString);
+            return ("*".equals(dimString) || dimString.isEmpty()) ? -1 : 
MathUtil.parseAsInt(dimString);
         } catch (Exception e) {
             throw new XmlValueOutOfRangeException("Malformed integer in SOAP 
array index");
         }
@@ -127,7 +127,7 @@ public final class SOAPArrayType {
                     // _hasIndeterminateDimensions = true;
                 } else {
                     try {
-                        _dimensions[i] = 
MathUtil.parseAsInteger(dimStrings[i]);
+                        _dimensions[i] = MathUtil.parseAsInt(dimStrings[i]);
                     } catch (Exception e) {
                         throw new XmlValueOutOfRangeException();
                     }
@@ -293,7 +293,7 @@ public final class SOAPArrayType {
                 // _hasIndeterminateDimensions = true;
             } else {
                 try {
-                    dimensions[i] = MathUtil.parseAsInteger(dimStrings[i]);
+                    dimensions[i] = MathUtil.parseAsInt(dimStrings[i]);
                 } catch (Exception e) {
                     throw new XmlValueOutOfRangeException();
                 }

Modified: xmlbeans/trunk/src/test/java/misc/checkin/XsTypeConverterTest.java
==============================================================================
--- xmlbeans/trunk/src/test/java/misc/checkin/XsTypeConverterTest.java  Fri Jul 
17 20:23:20 2026        (r1936283)
+++ xmlbeans/trunk/src/test/java/misc/checkin/XsTypeConverterTest.java  Fri Jul 
17 21:00:45 2026        (r1936284)
@@ -121,24 +121,26 @@ public class XsTypeConverterTest {
 
     @Test
     void lexFloatStrictRejectsNonXsdLexicalForms() {
+        final int maxNums = XmlOptions.DEFAULT_MAX_NUMBER_CHARS;
         // hex floats, the java "Infinity" spelling and the f/F/d/D suffix are
         // accepted by Float.parseFloat but are outside the xsd:float lexical 
space
-        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexFloat("0x1p4", true));
-        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexFloat("Infinity", true));
-        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexFloat("-Infinity", true));
-        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexFloat("1.0d", true));
-        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexFloat("1D", true));
-        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexFloat("1.0f", true));
+        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexFloat("0x1p4", true, maxNums));
+        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexFloat("Infinity", true, maxNums));
+        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexFloat("-Infinity", true, maxNums));
+        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexFloat("1.0d", true, maxNums));
+        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexFloat("1D", true, maxNums));
+        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexFloat("1.0f", true, maxNums));
     }
 
     @Test
     void lexFloatStrictAcceptsValidValues() {
-        assertEquals(1.0f, XsTypeConverter.lexFloat("1.0", true));
-        assertEquals(1.0f, XsTypeConverter.lexFloat("01.0", true));
-        assertEquals(1500.0f, XsTypeConverter.lexFloat("1.5e3", true));
-        assertEquals(Float.POSITIVE_INFINITY, XsTypeConverter.lexFloat("INF", 
true));
-        assertEquals(Float.NEGATIVE_INFINITY, XsTypeConverter.lexFloat("-INF", 
true));
-        assertEquals(Float.NaN, XsTypeConverter.lexFloat("NaN", true));
+        final int maxNums = XmlOptions.DEFAULT_MAX_NUMBER_CHARS;
+        assertEquals(1.0f, XsTypeConverter.lexFloat("1.0", true, maxNums));
+        assertEquals(1.0f, XsTypeConverter.lexFloat("01.0", true, maxNums));
+        assertEquals(1500.0f, XsTypeConverter.lexFloat("1.5e3", true, 
maxNums));
+        assertEquals(Float.POSITIVE_INFINITY, XsTypeConverter.lexFloat("INF", 
true, maxNums));
+        assertEquals(Float.NEGATIVE_INFINITY, XsTypeConverter.lexFloat("-INF", 
true, maxNums));
+        assertEquals(Float.NaN, XsTypeConverter.lexFloat("NaN", true, 
maxNums));
     }
 
     @Test
@@ -158,24 +160,26 @@ public class XsTypeConverterTest {
 
     @Test
     void lexDoubleStrictRejectsNonXsdLexicalForms() {
+        final int maxNums = XmlOptions.DEFAULT_MAX_NUMBER_CHARS;
         // hex floats, the java "Infinity" spelling and the f/F/d/D suffix are
         // accepted by Double.parseDouble but are outside the xsd:double 
lexical space
-        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexDouble("0x1p4", true));
-        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexDouble("Infinity", true));
-        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexDouble("-Infinity", true));
-        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexDouble("1.0f", true));
-        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexDouble("1F", true));
-        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexDouble("1.0d", true));
+        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexDouble("0x1p4", true, maxNums));
+        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexDouble("Infinity", true, maxNums));
+        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexDouble("-Infinity", true, maxNums));
+        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexDouble("1.0f", true, maxNums));
+        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexDouble("1F", true, maxNums));
+        assertThrows(NumberFormatException.class, () -> 
XsTypeConverter.lexDouble("1.0d", true, maxNums));
     }
 
     @Test
     void lexDoubleStrictAcceptsValidValues() {
-        assertEquals(1.0, XsTypeConverter.lexDouble("1.0", true));
-        assertEquals(1.0, XsTypeConverter.lexDouble("01.0", true));
-        assertEquals(1500.0, XsTypeConverter.lexDouble("1.5e3", true));
-        assertEquals(Double.POSITIVE_INFINITY, 
XsTypeConverter.lexDouble("INF", true));
-        assertEquals(Double.NEGATIVE_INFINITY, 
XsTypeConverter.lexDouble("-INF", true));
-        assertEquals(Double.NaN, XsTypeConverter.lexDouble("NaN", true));
+        final int maxNums = XmlOptions.DEFAULT_MAX_NUMBER_CHARS;
+        assertEquals(1.0, XsTypeConverter.lexDouble("1.0", true, maxNums));
+        assertEquals(1.0, XsTypeConverter.lexDouble("01.0", true, maxNums));
+        assertEquals(1500.0, XsTypeConverter.lexDouble("1.5e3", true, 
maxNums));
+        assertEquals(Double.POSITIVE_INFINITY, 
XsTypeConverter.lexDouble("INF", true, maxNums));
+        assertEquals(Double.NEGATIVE_INFINITY, 
XsTypeConverter.lexDouble("-INF", true, maxNums));
+        assertEquals(Double.NaN, XsTypeConverter.lexDouble("NaN", true, 
maxNums));
     }
 
     @Test


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to