x.json2: cleanup code, add more tests (fix #26033) (#26064)

kbkpbot · web-flow · commit 703eca868f85 · 2025-12-21T19:30:52.000+02:00
diff --git a/vlib/x/json2/decode.v b/vlib/x/json2/decode.v
@@ -823,68 +823,6 @@ fn create_value_from_optional[T](val ?T) ?T {
 	return T{}
 }
 
-fn get_number_max[T](num T) T {
-	$if num is i8 {
-		return max_i8
-	} $else $if num is i16 {
-		return max_i16
-	} $else $if num is i32 {
-		return max_i32
-	} $else $if num is i64 {
-		return max_i64
-	} $else $if num is u8 {
-		return max_u8
-	} $else $if num is u16 {
-		return max_u16
-	} $else $if num is u32 {
-		return max_u32
-	} $else $if num is u64 {
-		return max_u64
-	} $else $if num is int {
-		return max_int
-	}
-	return 0
-}
-
-fn get_number_min[T](num T) T {
-	$if num is i8 {
-		return min_i8
-	} $else $if num is i16 {
-		return min_i16
-	} $else $if num is i32 {
-		return min_i32
-	} $else $if num is i64 {
-		return min_i64
-	} $else $if num is u8 {
-		return min_u8
-	} $else $if num is u16 {
-		return min_u16
-	} $else $if num is u32 {
-		return min_u32
-	} $else $if num is u64 {
-		return min_u64
-	} $else $if num is int {
-		return min_int
-	}
-	return 0
-}
-
-fn get_number_digits[T](num T) int {
-	return $if T.unaliased_typ is i8 || T.unaliased_typ is u8 {
-		3
-	} $else $if T.unaliased_typ is i16 || T.unaliased_typ is u16 {
-		5
-	} $else $if T.unaliased_typ is i32 || T.unaliased_typ is u32 || T.unaliased_typ is int {
-		10
-	} $else $if T.unaliased_typ is i64 {
-		19
-	} $else $if T.unaliased_typ is u64 {
-		20
-	} $else {
-		0
-	}
-}
-
 fn (mut decoder Decoder) decode_enum[T](mut val T) ! {
 	enum_info := decoder.current_node.value
 
@@ -927,22 +865,18 @@ fn (mut decoder Decoder) decode_number[T](val &T) ! {
 		}
 	}
 
-	$if T.unaliased_typ is $float {
-		*val = T(strconv.atof_quick(decoder.json[number_info.position..number_info.position +
-			number_info.length]))
-	} $else {
-		str := decoder.json[number_info.position..number_info.position + number_info.length]
-		$match T.unaliased_typ {
-			i8 { *val = strconv.atoi8(str)! }
-			i16 { *val = strconv.atoi16(str)! }
-			i32 { *val = strconv.atoi32(str)! }
-			i64 { *val = strconv.atoi64(str)! }
-			u8 { *val = strconv.atou8(str)! }
-			u16 { *val = strconv.atou16(str)! }
-			u32 { *val = strconv.atou32(str)! }
-			u64 { *val = strconv.atou64(str)! }
-			int { *val = strconv.atoi(str)! }
-			$else { return error('`decode_number` can not decode ${T.name} type') }
-		}
+	str := decoder.json[number_info.position..number_info.position + number_info.length]
+	$match T.unaliased_typ {
+		i8 { *val = strconv.atoi8(str)! }
+		i16 { *val = strconv.atoi16(str)! }
+		i32 { *val = strconv.atoi32(str)! }
+		i64 { *val = strconv.atoi64(str)! }
+		u8 { *val = strconv.atou8(str)! }
+		u16 { *val = strconv.atou16(str)! }
+		u32 { *val = strconv.atou32(str)! }
+		u64 { *val = strconv.atou64(str)! }
+		int { *val = strconv.atoi(str)! }
+		$float { *val = T(strconv.atof_quick(str)) }
+		$else { return error('`decode_number` can not decode ${T.name} type') }
 	}
 }
diff --git a/vlib/x/json2/tests/decode_struct_test.v b/vlib/x/json2/tests/decode_struct_test.v
@@ -1,5 +1,6 @@
 import x.json2 as json
 import time
+import math
 
 const fixed_time = time.new(
 	year:   2022
@@ -74,19 +75,222 @@ fn test_option_types() {
 	}
 }
 
+// Test structure for basic number types
+struct JsonNumbers {
+	val_i8  i8
+	val_i16 i16
+	val_i32 i32
+	val_i64 i64
+	val_u8  u8
+	val_u16 u16
+	val_u32 u32
+	val_u64 u64
+	val_int int
+	val_f32 f32
+	val_f64 f64
+}
+
+// Test structure for float precision
+struct JsonFloats {
+	val_f32 f32
+	val_f64 f64
+}
+
+// Test basic functionality
 struct JsonU8 {
 	val1 u8
 	val2 u8
 }
 
-fn test_u8_vals() {
+fn test_u8_values() {
 	x := JsonU8{
 		val1: 58
 		val2: 58
 	}
 
 	str := json.encode(x)
-
 	y := json.decode[JsonU8](str) or { panic(err) }
 	assert x == y
+	println('✓ Basic u8 test passed')
+}
+
+fn test_all_number_types() {
+	// Test normal range values
+	x := JsonNumbers{
+		val_i8:  -100
+		val_i16: -1000
+		val_i32: -100000
+		val_i64: -1000000000
+		val_u8:  58
+		val_u16: 2000
+		val_u32: 200000
+		val_u64: 2000000000
+		val_int: 300000
+		val_f32: 3.14
+		val_f64: 2.71828
+	}
+
+	str := json.encode(x)
+	y := json.decode[JsonNumbers](str) or { panic('Decoding failed: ${err}') }
+
+	assert x.val_i8 == y.val_i8
+	assert x.val_i16 == y.val_i16
+	assert x.val_i32 == y.val_i32
+	assert x.val_i64 == y.val_i64
+	assert x.val_u8 == y.val_u8
+	assert x.val_u16 == y.val_u16
+	assert x.val_u32 == y.val_u32
+	assert x.val_u64 == y.val_u64
+	assert x.val_int == y.val_int
+	assert math.alike(x.val_f32, y.val_f32)
+	assert math.alike(x.val_f64, y.val_f64)
+
+	println('✓ All number types test passed')
+}
+
+fn test_number_boundaries() {
+	// Test minimum and maximum values for various types
+	test_cases := [
+		json.encode(JsonU8{ val1: 0, val2: 255 }),
+		json.encode(JsonU8{ val1: u8(128), val2: u8(255) }),
+		'{"min_i8": -128, "max_i8": 127}',
+		'{"min_u8": 0, "max_u8": 255}',
+		'{"zero": 0}',
+	]!
+
+	for case in test_cases {
+		result := json.decode[JsonU8](case)!
+		assert result.val1 >= 0 && result.val1 <= 255
+		assert result.val2 >= 0 && result.val2 <= 255
+	}
+	println('✓ Boundary values test passed')
+}
+
+fn test_fake_numbers() {
+	// Test quoted numbers (fake numbers)
+	fake_number_cases := [
+		'{"val1": "123", "val2": "45"}', // Fully quoted
+		'{"val1": 123, "val2": "45"}', // Mixed format
+		'{"val1": "255", "val2": 0}', // Boundary value as string
+	]!
+
+	for case in fake_number_cases {
+		result := json.decode[JsonU8](case) or {
+			panic('Fake number decoding failed: ${err}, input: ${case}')
+		}
+		assert result.val1 >= 0 && result.val1 <= 255
+		assert result.val2 >= 0 && result.val2 <= 255
+	}
+	println('✓ Fake numbers (quoted numbers) test passed')
+}
+
+fn test_error_conditions() {
+	// Test invalid inputs that should trigger errors
+	invalid_cases := [
+		'{"val1": "abc", "val2": 58}', // Non-numeric string
+		'{"val1": "", "val2": 58}', // Empty string
+		'{"val1": 300, "val2": 58}', // Out of u8 range (300 > 255)
+		'{"val1": -1, "val2": 58}', // Negative value for u8
+		'{"val1": 123.45, "val2": 58}', // Float for integer type
+	]!
+
+	mut error_count := 0
+	for case in invalid_cases {
+		result := json.decode[JsonU8](case) or {
+			error_count++
+			continue // Expected failure, error handling works correctly
+		}
+		// If we reach here, it means decoding succeeded when it should have failed
+		panic('Expected decoding to fail but succeeded: ${case}')
+	}
+	assert error_count > 0 // Ensure we caught some errors
+	println('✓ Error handling test passed')
+}
+
+fn test_float_precision() {
+	// Test floating point precision and scientific notation
+	test_cases := [
+		JsonFloats{
+			val_f32: 3.14159265
+			val_f64: 2.718281828459045
+		},
+		JsonFloats{
+			val_f32: 1.0e10
+			val_f64: 1.0e-10
+		},
+		JsonFloats{
+			val_f32: -123.456
+			val_f64: -789.012
+		},
+		JsonFloats{
+			val_f32: 0.0
+			val_f64: 0.0
+		},
+	]!
+
+	for x in test_cases {
+		str := json.encode(x)
+		y := json.decode[JsonFloats](str) or { panic('Float decoding failed: ${err}') }
+
+		// Use relative error for assertions
+		assert math.alike(y.val_f32, x.val_f32)
+		assert math.alike(y.val_f64, x.val_f64)
+	}
+	println('✓ Float precision test passed')
+}
+
+fn test_performance_large_scale() {
+	// Performance test: decode large numbers of values
+	mut total := u64(0)
+
+	for i in 0 .. 1000 {
+		x := JsonU8{
+			val1: u8(i % 256)
+			val2: u8((i * 7) % 256)
+		}
+		str := json.encode(x)
+		y := json.decode[JsonU8](str) or { panic('Performance test decoding failed: ${err}') }
+		total += y.val1 + y.val2
+	}
+
+	assert total > 0 // Ensure the loop executed
+	println('✓ Performance test passed')
+}
+
+fn test_special_float_values() {
+	// Test special float values
+
+	// Json does not support nan, +-inf yet
+	assert json.encode(math.nan()) == 'nan'
+	assert json.encode(math.inf(1)) == '+inf'
+	assert json.encode(math.inf(-1)) == '-inf'
+
+	println('✓ Special float values test passed')
+}
+
+fn test_json_format_consistency() {
+	// Test that encoding and decoding preserves data integrity
+	original := JsonNumbers{
+		val_i8:  100
+		val_i16: 1000
+		val_i32: 100000
+		val_i64: 1000000000
+		val_u8:  33
+		val_u16: 2000
+		val_u32: 200000
+		val_u64: 2000000000
+		val_int: 300000
+		val_f32: 3.14
+		val_f64: 2.71828
+	}
+
+	// Encode and decode multiple times
+	str1 := json.encode(original)
+	decoded1 := json.decode[JsonNumbers](str1) or { panic('First decode failed: ${err}') }
+	str2 := json.encode(decoded1)
+	decoded2 := json.decode[JsonNumbers](str2) or { panic('Second decode failed: ${err}') }
+
+	// All versions should be equivalent
+	assert decoded1 == decoded2
+	println('✓ JSON format consistency test passed')
 }
