clarify ONGOING_CHUNK_MULTIPLIER

src/number_decoder.rs

@@ -85,7 +85,7 @@
                 json_err!(InvalidNumber, index)
             }
         } else {
             json_err!(EofWhileParsingValue, index)
         }
     }
 }
@@ -210,7 +210,7 @@
             let (chunk, new_index) = IntChunk::parse_big(data, index);
             match chunk {
                 IntChunk::Ongoing(value) => {
-                    big_value *= ONGOING_CHUNK_SIZE;
+                    big_value *= ONGOING_CHUNK_MULTIPLIER;
                     big_value += value;
                     index = new_index;
                 }
@@ -253,9 +253,11 @@
 ];
 
 #[cfg(target_arch = "aarch64")]
-static ONGOING_CHUNK_SIZE: u64 = POW_10[16];
+// in aarch64 we use a 128 bit registers - 16 bytes
+static ONGOING_CHUNK_MULTIPLIER: u64 = 10u64.pow(16);
 #[cfg(not(target_arch = "aarch64"))]
-static ONGOING_CHUNK_SIZE: u64 = POW_10[17];
+// decode_int_chunk_fallback - we parse 18 bytes when the number is ongoing
+static ONGOING_CHUNK_MULTIPLIER: u64 = 10u64.pow(18);
 
 pub(crate) enum IntChunk {
     Ongoing(u64),
@@ -286,8 +288,8 @@
 
 #[inline(always)]
 pub(crate) fn decode_int_chunk_fallback(data: &[u8], mut index: usize, mut value: u64) -> (IntChunk, usize) {
-    // i64::MAX = 9223372036854775807 - 18 chars is always enough
-    for _ in 1..18 {
+    // i64::MAX = 9223372036854775807 (19 chars) - so 18 chars is always valid as an i64
+    for _ in 0..18 {
         if let Some(digit) = data.get(index) {
             if INT_CHAR_MAP[*digit as usize] {
                 // we use wrapping add to avoid branching - we know the value cannot wrap

tests/main.rs

@@ -1295,3 +1295,28 @@ fn jiter_next_value_owned() {
     assert_eq!(s, "v");
     assert!(matches!(s, Cow::Owned(_)));
 }
+
+#[test]
+fn i64_max() {
+    let json = "9223372036854775807";
+    assert_eq!(i64::MAX.to_string(), json);
+    let v = JsonValue::parse(json.as_bytes(), false).unwrap();
+    match v {
+        JsonValue::Int(v) => assert_eq!(v, i64::MAX),
+        JsonValue::BigInt(v) => assert_eq!(v, i64::MAX.into()),
+        _ => panic!("expected int"),
+    }
+}
+
+#[test]
+fn test_all_int_lengths() {
+    for int_size in 1..100 {
+        let json = "9".repeat(int_size);
+        let v = JsonValue::parse(json.as_bytes(), false).unwrap();
+        match v {
+            JsonValue::Int(v) => assert_eq!(v.to_string(), json),
+            JsonValue::BigInt(v) => assert_eq!(v.to_string(), json),
+            _ => panic!("expected int"),
+        }
+    }
+}