This is an automated email from the ASF dual-hosted git repository.
jamesbognar pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/juneau.git
The following commit(s) were added to refs/heads/master by this push:
new 0de6a3ac6 Minor refactoring.
0de6a3ac6 is described below
commit 0de6a3ac620a898e6527b5e27b84a2e6d27af9cc
Author: JamesBognar <[email protected]>
AuthorDate: Fri Jul 1 14:49:11 2022 -0400
Minor refactoring.
---
.../org/apache/juneau/internal/StringUtils.java | 117 ++++++++++-----------
.../juneau/json/JsonParserEdgeCasesTest.java | 78 +++++++-------
.../rest/Rest_PredefinedStatusCodes_Test.java | 2 +-
.../client/RestClient_Response_Headers_Test.java | 2 +-
.../org/apache/juneau/utils/StringUtilsTest.java | 5 +-
5 files changed, 99 insertions(+), 105 deletions(-)
diff --git
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/internal/StringUtils.java
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/internal/StringUtils.java
index 86d2d16a3..89850aed6 100644
---
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/internal/StringUtils.java
+++
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/internal/StringUtils.java
@@ -33,7 +33,6 @@ import java.util.zip.*;
import javax.xml.bind.*;
import org.apache.juneau.*;
-import org.apache.juneau.parser.ParseException;
import org.apache.juneau.reflect.*;
/**
@@ -110,73 +109,69 @@ public final class StringUtils {
if (type == null)
type = Number.class;
- try {
- // Determine the data type if it wasn't specified.
- boolean isAutoDetect = (type == Number.class);
- boolean isDecimal = false;
- if (isAutoDetect) {
- // If we're auto-detecting, then we use either
an Integer, Long, or Double depending on how
- // long the string is.
- // An integer range is -2,147,483,648 to
2,147,483,647
- // An long range is -9,223,372,036,854,775,808
to +9,223,372,036,854,775,807
- isDecimal = isDecimal(s);
- if (isDecimal) {
- if (s.length() > 20)
- type = Double.class;
- else if (s.length() >= 10)
- type = Long.class;
- else
- type = Integer.class;
- }
- else if (isFloat(s))
+ // Determine the data type if it wasn't specified.
+ boolean isAutoDetect = (type == Number.class);
+ boolean isDecimal = false;
+ if (isAutoDetect) {
+ // If we're auto-detecting, then we use either an
Integer, Long, or Double depending on how
+ // long the string is.
+ // An integer range is -2,147,483,648 to 2,147,483,647
+ // An long range is -9,223,372,036,854,775,808 to
+9,223,372,036,854,775,807
+ isDecimal = isDecimal(s);
+ if (isDecimal) {
+ if (s.length() > 20)
type = Double.class;
+ else if (s.length() >= 10)
+ type = Long.class;
else
- throw new NumberFormatException(s);
+ type = Integer.class;
}
+ else if (isFloat(s))
+ type = Double.class;
+ else
+ throw new NumberFormatException(s);
+ }
- if (type == Double.class || type == Double.TYPE) {
- Double d = Double.valueOf(s);
- Float f = Float.valueOf(s);
- if (isAutoDetect && (!isDecimal) &&
d.toString().equals(f.toString()))
- return f;
- return d;
- }
- if (type == Float.class || type == Float.TYPE)
- return Float.valueOf(s);
- if (type == BigDecimal.class)
- return new BigDecimal(s);
- if (type == Long.class || type == Long.TYPE || type ==
AtomicLong.class) {
- try {
- Long l = Long.decode(s);
- if (type == AtomicLong.class)
- return new AtomicLong(l);
- if (isAutoDetect && l >=
Integer.MIN_VALUE && l <= Integer.MAX_VALUE) {
- // This occurs if the string is
10 characters long but is still a valid integer value.
- return l.intValue();
- }
- return l;
- } catch (NumberFormatException e) {
- if (isAutoDetect) {
- // This occurs if the string is
20 characters long but still falls outside the range of a valid long.
- return Double.valueOf(s);
- }
- throw e;
+ if (type == Double.class || type == Double.TYPE) {
+ Double d = Double.valueOf(s);
+ Float f = Float.valueOf(s);
+ if (isAutoDetect && (!isDecimal) &&
d.toString().equals(f.toString()))
+ return f;
+ return d;
+ }
+ if (type == Float.class || type == Float.TYPE)
+ return Float.valueOf(s);
+ if (type == BigDecimal.class)
+ return new BigDecimal(s);
+ if (type == Long.class || type == Long.TYPE || type ==
AtomicLong.class) {
+ try {
+ Long l = Long.decode(s);
+ if (type == AtomicLong.class)
+ return new AtomicLong(l);
+ if (isAutoDetect && l >= Integer.MIN_VALUE && l
<= Integer.MAX_VALUE) {
+ // This occurs if the string is 10
characters long but is still a valid integer value.
+ return l.intValue();
}
+ return l;
+ } catch (NumberFormatException e) {
+ if (isAutoDetect) {
+ // This occurs if the string is 20
characters long but still falls outside the range of a valid long.
+ return Double.valueOf(s);
+ }
+ throw e;
}
- if (type == Integer.class || type == Integer.TYPE)
- return Integer.decode(s);
- if (type == Short.class || type == Short.TYPE)
- return Short.decode(s);
- if (type == Byte.class || type == Byte.TYPE)
- return Byte.decode(s);
- if (type == BigInteger.class)
- return new BigInteger(s);
- if (type == AtomicInteger.class)
- return new AtomicInteger(Integer.decode(s));
- throw new ParseException("Unsupported Number type:
{0}", type.getName());
- } catch (NumberFormatException e) {
- throw new ParseException(e, "Invalid number: ''{0}'',
class=''{1}''", s, type.getSimpleName());
}
+ if (type == Integer.class || type == Integer.TYPE)
+ return Integer.decode(s);
+ if (type == Short.class || type == Short.TYPE)
+ return Short.decode(s);
+ if (type == Byte.class || type == Byte.TYPE)
+ return Byte.decode(s);
+ if (type == BigInteger.class)
+ return new BigInteger(s);
+ if (type == AtomicInteger.class)
+ return new AtomicInteger(Integer.decode(s));
+ throw new NumberFormatException("Unsupported Number type:
"+type.getName());
}
private static final Pattern fpRegex = Pattern.compile(
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/json/JsonParserEdgeCasesTest.java
b/juneau-utest/src/test/java/org/apache/juneau/json/JsonParserEdgeCasesTest.java
index e1c32e647..9aa3df6be 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/json/JsonParserEdgeCasesTest.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/json/JsonParserEdgeCasesTest.java
@@ -66,7 +66,7 @@ public class JsonParserEdgeCasesTest {
{ 30, "n_array_inner_array_no_comma", "[3[4]]",
"Expected ',' or ']'" },
{ 31, "n_array_items_separated_by_semicolon", "[1:2]",
"Expected ',' or ']'" },
{ 32, "n_array_just_comma", "[,]", null },
- { 33, "n_array_just_minus", "[-]", "Invalid number" },
+ { 33, "n_array_just_minus", "[-]",
"NumberFormatException" },
{ 34, "n_array_missing_value", "[ , \"\"]", "Missing
value detected" },
{ 35, "n_array_number_and_comma", "[1,]", "Unexpected
trailing comma in array" },
{ 36, "n_array_number_and_several_commas", "[1,,]",
null },
@@ -81,47 +81,47 @@ public class JsonParserEdgeCasesTest {
{ 45, "n_number_+1", "[+1]", "Unrecognized syntax" },
{ 46, "n_number_+Inf", "[+Inf]", "Unrecognized syntax"
},
{ 47, "n_number_-01", "[-01]", "Invalid JSON number" },
- { 48, "n_number_-1.0.", "[-1.0.]", "Invalid number" },
+ { 48, "n_number_-1.0.", "[-1.0.]",
"NumberFormatException" },
{ 49, "n_number_-2.", "[-2.]", "Invalid JSON number" },
{ 50, "n_number_-NaN", "[-NaN]", null },
- { 51, "n_number_.-1", "[.-1]", "Invalid" },
+ { 51, "n_number_.-1", "[.-1]", null },
{ 52, "n_number_.2e-3", "[.2e-3]", "Invalid JSON
number" },
- { 53, "n_number_0.1.2", "[0.1.2]", "Invalid number" },
- { 54, "n_number_0.3e+", "[0.3e+]", "Invalid number" },
- { 55, "n_number_0.3e", "[0.3e]", "Invalid number" },
+ { 53, "n_number_0.1.2", "[0.1.2]",
"NumberFormatException" },
+ { 54, "n_number_0.3e+", "[0.3e+]",
"NumberFormatException" },
+ { 55, "n_number_0.3e", "[0.3e]",
"NumberFormatException" },
{ 56, "n_number_0.e1", "[0.e1]", "Invalid JSON number"
},
- { 57, "n_number_0_capital_E+", "[0E+]", "Invalid
number" },
- { 58, "n_number_0_capital_E", "[0E]", "Invalid number"
},
- { 59, "n_number_0e+", "[0e+]", "Invalid number" },
- { 60, "n_number_0e", "[0e]", "Invalid number" },
- { 61, "n_number_1.0e+", "[1.0e+]", "Invalid number" },
- { 62, "n_number_1.0e-", "[1.0e-]", "Invalid number" },
- { 63, "n_number_1.0e", "[1.0e]", "Invalid number" },
+ { 57, "n_number_0_capital_E+", "[0E+]",
"NumberFormatException" },
+ { 58, "n_number_0_capital_E", "[0E]",
"NumberFormatException" },
+ { 59, "n_number_0e+", "[0e+]", "NumberFormatException"
},
+ { 60, "n_number_0e", "[0e]", "NumberFormatException" },
+ { 61, "n_number_1.0e+", "[1.0e+]",
"NumberFormatException" },
+ { 62, "n_number_1.0e-", "[1.0e-]",
"NumberFormatException" },
+ { 63, "n_number_1.0e", "[1.0e]",
"NumberFormatException" },
{ 64, "n_number_1_000", "[1 000.0]", "Expected ',' or
']'" },
- { 65, "n_number_1eE2", "[1eE2]", "Invalid number" },
+ { 65, "n_number_1eE2", "[1eE2]",
"NumberFormatException" },
{ 66, "n_number_2.e+3", "[2.e+3]", "Invalid JSON
number" },
{ 67, "n_number_2.e-3", "[2.e-3]", "Invalid JSON
number" },
{ 68, "n_number_2.e3", "[2.e3]", "Invalid JSON number"
},
{ 69, "n_number_9.e+", "[9.e+]", null },
- { 70, "n_number_expression", "[1+2]", "Invalid number"
},
+ { 70, "n_number_expression", "[1+2]",
"NumberFormatException" },
{ 71, "n_number_hex_1_digit", "[0x1]", "Invalid JSON
number" },
{ 72, "n_number_hex_2_digits", "[0x42]", "Invalid JSON
number" },
{ 73, "n_number_Inf", "[Inf]", "Unrecognized syntax" },
{ 74, "n_number_infinity", "[Infinity]", "Unrecognized
syntax" },
- { 75, "n_number_invalid+-", "[0e+-1]", "Invalid number"
},
+ { 75, "n_number_invalid+-", "[0e+-1]",
"NumberFormatException" },
{ 76, "n_number_invalid-negative-real",
"[-123.123foo]", "Expected ',' or ']'" },
{ 77, "n_number_minus_infinity", "[-Infinity]", null },
- { 78, "n_number_minus_sign_with_trailing_garbage",
"[-foo]", "Invalid number" },
+ { 78, "n_number_minus_sign_with_trailing_garbage",
"[-foo]", "NumberFormatException" },
{ 79, "n_number_minus_space_1", "[- 1]", null },
{ 80, "n_number_NaN", "[NaN]", "Unrecognized syntax" },
{ 81, "n_number_neg_int_starting_with_zero", "[-012]",
"Invalid JSON number" },
{ 82, "n_number_neg_real_without_int_part", "[-.123]",
"Invalid JSON number" },
- { 83, "n_number_neg_with_garbage_at_end", "[-1x]",
"Invalid number" },
- { 84, "n_number_real_garbage_after_e", "[1ea]",
"Invalid number" },
+ { 83, "n_number_neg_with_garbage_at_end", "[-1x]",
"NumberFormatException" },
+ { 84, "n_number_real_garbage_after_e", "[1ea]",
"NumberFormatException" },
{ 85, "n_number_real_without_fractional_part", "[1.]",
"Invalid" },
{ 86, "n_number_starting_with_dot", "[.123]", "Invalid
JSON number" },
{ 87, "n_number_U+FF11_fullwidth_digit_one", "[１]",
"Unrecognized syntax" },
- { 88, "n_number_with_alpha", "[1.2a-3]", "Invalid
number" },
+ { 88, "n_number_with_alpha", "[1.2a-3]",
"NumberFormatException" },
{ 89, "n_number_with_alpha_char",
"[1.8011670033376514H-308]", "Expected ',' or ']'" },
{ 90, "n_number_with_leading_zero", "[012]", "Invalid
JSON number" },
{ 91, "n_object_bad_value", "[\"x\", truth]",
"Unrecognized syntax" },
@@ -500,7 +500,7 @@ public class JsonParserEdgeCasesTest {
errors.put(/*29*/ "n_array_incomplete_invalid_value",
"Unrecognized syntax");
errors.put(/*30*/ "n_array_inner_array_no_comma", "Expected ','
or ']'");
errors.put(/*31*/ "n_array_items_separated_by_semicolon",
"Expected ',' or ']'");
- errors.put(/*33*/ "n_array_just_minus", "Invalid number");
+ errors.put(/*33*/ "n_array_just_minus",
"NumberFormatException");
errors.put(/*34*/ "n_array_missing_value", "Missing value
detected");
errors.put(/*35*/ "n_array_number_and_comma", "Unexpected
trailing comma in array");
errors.put(/*37*/ "n_array_star_inside", "Unrecognized syntax");
@@ -514,43 +514,43 @@ public class JsonParserEdgeCasesTest {
errors.put(/*45*/ "n_number_+1", "Unrecognized syntax");
errors.put(/*46*/ "n_number_+Inf", "Unrecognized syntax");
errors.put(/*47*/ "n_number_-01", "Invalid JSON number");
- errors.put(/*48*/ "n_number_-1.0.", "Invalid number");
+ errors.put(/*48*/ "n_number_-1.0.", "NumberFormatException");
errors.put(/*49*/ "n_number_-2.", "Invalid JSON number");
errors.put(/*51*/ "n_number_.-1", "Invalid");
errors.put(/*52*/ "n_number_.2e-3", "Invalid JSON number");
- errors.put(/*53*/ "n_number_0.1.2", "Invalid number");
- errors.put(/*54*/ "n_number_0.3e+", "Invalid number");
- errors.put(/*55*/ "n_number_0.3e", "Invalid number");
+ errors.put(/*53*/ "n_number_0.1.2", "NumberFormatException");
+ errors.put(/*54*/ "n_number_0.3e+", "NumberFormatException");
+ errors.put(/*55*/ "n_number_0.3e", "NumberFormatException");
errors.put(/*56*/ "n_number_0.e1", "Invalid JSON number");
- errors.put(/*57*/ "n_number_0_capital_E+", "Invalid number");
- errors.put(/*58*/ "n_number_0_capital_E", "Invalid number");
- errors.put(/*59*/ "n_number_0e+", "Invalid number");
- errors.put(/*60*/ "n_number_0e", "Invalid number");
- errors.put(/*61*/ "n_number_1.0e+", "Invalid number");
- errors.put(/*62*/ "n_number_1.0e-", "Invalid number");
- errors.put(/*63*/ "n_number_1.0e", "Invalid number");
+ errors.put(/*57*/ "n_number_0_capital_E+",
"NumberFormatException");
+ errors.put(/*58*/ "n_number_0_capital_E",
"NumberFormatException");
+ errors.put(/*59*/ "n_number_0e+", "NumberFormatException");
+ errors.put(/*60*/ "n_number_0e", "NumberFormatException");
+ errors.put(/*61*/ "n_number_1.0e+", "NumberFormatException");
+ errors.put(/*62*/ "n_number_1.0e-", "NumberFormatException");
+ errors.put(/*63*/ "n_number_1.0e", "NumberFormatException");
errors.put(/*64*/ "n_number_1_000", "Expected ',' or ']'");
- errors.put(/*65*/ "n_number_1eE2", "Invalid number");
+ errors.put(/*65*/ "n_number_1eE2", "NumberFormatException");
errors.put(/*66*/ "n_number_2.e+3", "Invalid JSON number");
errors.put(/*67*/ "n_number_2.e-3", "Invalid JSON number");
errors.put(/*68*/ "n_number_2.e3", "Invalid JSON number");
- errors.put(/*70*/ "n_number_expression", "Invalid number");
+ errors.put(/*70*/ "n_number_expression",
"NumberFormatException");
errors.put(/*71*/ "n_number_hex_1_digit", "Invalid JSON
number");
errors.put(/*72*/ "n_number_hex_2_digits", "Invalid JSON
number");
errors.put(/*73*/ "n_number_Inf", "Unrecognized syntax");
errors.put(/*74*/ "n_number_infinity", "Unrecognized syntax");
- errors.put(/*75*/ "n_number_invalid+-", "Invalid number");
+ errors.put(/*75*/ "n_number_invalid+-",
"NumberFormatException");
errors.put(/*76*/ "n_number_invalid-negative-real", "Expected
',' or ']'");
- errors.put(/*78*/ "n_number_minus_sign_with_trailing_garbage",
"Invalid number");
+ errors.put(/*78*/ "n_number_minus_sign_with_trailing_garbage",
"NumberFormatException");
errors.put(/*80*/ "n_number_NaN", "Unrecognized syntax");
errors.put(/*81*/ "n_number_neg_int_starting_with_zero",
"Invalid JSON number");
errors.put(/*82*/ "n_number_neg_real_without_int_part",
"Invalid JSON number");
- errors.put(/*83*/ "n_number_neg_with_garbage_at_end", "Invalid
number");
- errors.put(/*84*/ "n_number_real_garbage_after_e", "Invalid
number");
+ errors.put(/*83*/ "n_number_neg_with_garbage_at_end",
"NumberFormatException");
+ errors.put(/*84*/ "n_number_real_garbage_after_e",
"NumberFormatException");
errors.put(/*85*/ "n_number_real_without_fractional_part",
"Invalid");
errors.put(/*86*/ "n_number_starting_with_dot", "Invalid JSON
number");
errors.put(/*87*/ "n_number_U+FF11_fullwidth_digit_one",
"Unrecognized syntax");
- errors.put(/*88*/ "n_number_with_alpha", "Invalid number");
+ errors.put(/*88*/ "n_number_with_alpha",
"NumberFormatException");
errors.put(/*89*/ "n_number_with_alpha_char", "Expected ',' or
']'");
errors.put(/*90*/ "n_number_with_leading_zero", "Invalid JSON
number");
errors.put(/*91*/ "n_object_bad_value", "Unrecognized syntax");
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/rest/Rest_PredefinedStatusCodes_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/rest/Rest_PredefinedStatusCodes_Test.java
index e4e89999c..050339087 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/rest/Rest_PredefinedStatusCodes_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/rest/Rest_PredefinedStatusCodes_Test.java
@@ -131,7 +131,7 @@ public class Rest_PredefinedStatusCodes_Test {
.run()
.assertCode().is(400)
.assertContent().isContains(
- "Invalid number"
+ "NumberFormatException"
);
b.put("/c?noTrace=true", "{f1:1}", APPLICATION_JSON)
.run()
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Headers_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Headers_Test.java
index ec4a98211..a1ef88111 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Headers_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Headers_Test.java
@@ -128,7 +128,7 @@ public class RestClient_Response_Headers_Test {
checkFooClient().build().get("/echo").header("Foo","1,2").run().getHeader("Foo").as(m3,cm1);
assertObject(m3.get()).asJson().is("[1,2]");
-
assertThrown(()->checkFooClient().build().get("/echo").header("Foo","foo").run().getHeader("Foo").as(m2,cm1)).asMessages().isAny(contains("Invalid
number"));
+
assertThrown(()->checkFooClient().build().get("/echo").header("Foo","foo").run().getHeader("Foo").as(m2,cm1)).asMessages().isAny(contains("For
input string:"));
Optional<List<Integer>> o1 =
checkFooClient().build().get("/echo").header("Foo","1,2").run().getHeader("Foo").as(LinkedList.class,Integer.class);
assertObject(o1.get()).asJson().is("[1,2]");
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/utils/StringUtilsTest.java
b/juneau-utest/src/test/java/org/apache/juneau/utils/StringUtilsTest.java
index 1b216c022..4296a6b30 100755
--- a/juneau-utest/src/test/java/org/apache/juneau/utils/StringUtilsTest.java
+++ b/juneau-utest/src/test/java/org/apache/juneau/utils/StringUtilsTest.java
@@ -22,7 +22,6 @@ import java.util.*;
import org.apache.juneau.collections.*;
import org.apache.juneau.internal.*;
import org.apache.juneau.json.*;
-import org.apache.juneau.parser.*;
import org.apache.juneau.serializer.*;
import org.apache.juneau.testutils.*;
import org.junit.*;
@@ -245,11 +244,11 @@ public class StringUtilsTest {
s = String.valueOf("214748364x");
assertFalse(isNumeric(s));
- assertThrown(()->parseNumber(String.valueOf("214748364x"),
Number.class)).isType(ParseException.class);
+ assertThrown(()->parseNumber(String.valueOf("214748364x"),
Number.class)).isType(NumberFormatException.class);
s = String.valueOf("2147483640x");
assertFalse(isNumeric(s));
- assertThrown(()->parseNumber(String.valueOf("2147483640x"),
Long.class)).isType(ParseException.class);
+ assertThrown(()->parseNumber(String.valueOf("2147483640x"),
Long.class)).isType(NumberFormatException.class);
}
//====================================================================================================
