qubit-json 0.8.0

Resource-aware infrastructure for lenient and strict JSON processing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

// =============================================================================
//    Copyright (c) 2026 Haixing Hu.
//
//    SPDX-License-Identifier: Apache-2.0
//
//    Licensed under the Apache License, Version 2.0.
// =============================================================================
//! Tests compound budget-aware JSON serialization.

use qubit_budget::json::JsonEncodeLimits;
use qubit_budget::json::JsonEncodeSession;
use qubit_budget::json::JsonResource;
use serde::Serialize;
use serde::Serializer;

use crate::encode::json_encode_test_support::encode;

#[derive(Serialize)]
struct Pair {
    left: u8,
    right: u8,
}

#[derive(Serialize)]
struct Triple(u8, u8);

struct Bytes;

impl Serialize for Bytes {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_bytes(&[1, 10, 100])
    }
}

/// Byte values spanning every decimal-width branch used by JSON accounting.
struct BoundaryBytes;

impl Serialize for BoundaryBytes {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_bytes(&[9, 10, 99, 100, 255])
    }
}

/// Verifies compound serialization preserves object members.
#[test]
fn test_json_encode_compound_serializes_struct_members() {
    let mut session = JsonEncodeSession::from_limits(JsonEncodeLimits::<JsonResource, usize>::builder().build());
    let output = encode(&Pair { left: 1, right: 2 }, &mut session).expect("compound JSON should serialize");

    assert_eq!(output, br#"{"left":1,"right":2}"#);
}

/// Verifies tuple-struct compounds complete through the decorated end path.
#[test]
fn test_json_encode_compound_serializes_tuple_struct_fields() {
    let mut session = JsonEncodeSession::from_limits(JsonEncodeLimits::<JsonResource, usize>::builder().build());
    let output = encode(&Triple(3, 4), &mut session).expect("tuple-struct JSON should serialize");

    assert_eq!(output, b"[3,4]");
}

/// Verifies byte-array numbers use their exact decimal widths for both the
/// point number limit and the cumulative value-payload limit.
#[test]
fn test_json_encode_bytes_charge_decimal_width_boundaries() {
    let exact_limits = JsonEncodeLimits::<JsonResource, usize>::builder()
        .max_number_bytes(3)
        .max_payload_bytes(11)
        .build();
    let mut exact = JsonEncodeSession::from_limits(exact_limits);

    assert_eq!(
        encode(&BoundaryBytes, &mut exact).expect("exact byte budgets must fit"),
        b"[9,10,99,100,255]",
    );

    let number_limits = JsonEncodeLimits::<JsonResource, usize>::builder()
        .max_number_bytes(2)
        .build();
    let mut short_number = JsonEncodeSession::from_limits(number_limits);
    assert!(
        encode(&BoundaryBytes, &mut short_number).is_err(),
        "100 must cross the two-to-three-digit number boundary",
    );

    let payload_limits = JsonEncodeLimits::<JsonResource, usize>::builder()
        .max_payload_bytes(10)
        .build();
    let mut short_payload = JsonEncodeSession::from_limits(payload_limits);
    assert!(
        encode(&BoundaryBytes, &mut short_payload).is_err(),
        "decimal byte widths must consume eleven payload bytes",
    );
}

/// Verifies scalar serializer paths instantiate with byte-sized quantities.
#[test]
fn test_json_encode_scalar_paths_support_u8_quantities() {
    macro_rules! assert_scalar {
        ($value:expr) => {{
            let mut session = JsonEncodeSession::<JsonResource, u8>::from_limits(
                JsonEncodeLimits::<JsonResource, u8>::builder().build(),
            );
            encode(&$value, &mut session).expect("scalar should fit an unconfigured budget");
        }};
    }

    assert_scalar!(-1_i8);
    assert_scalar!(-1_i16);
    assert_scalar!(-1_i32);
    assert_scalar!(-1_i64);
    assert_scalar!(-1_i128);
    assert_scalar!(1_u8);
    assert_scalar!(1_u16);
    assert_scalar!(1_u32);
    assert_scalar!(1_u64);
    assert_scalar!(1_u128);
    assert_scalar!(1.5_f32);
    assert_scalar!(2.5_f64);
    assert_scalar!('x');
    assert_scalar!("text");
    assert_scalar!(Some(1_u8));
    assert_scalar!(None::<u8>);
    assert_scalar!(());
    assert_scalar!(vec![1_u8]);
    assert_scalar!(Bytes);
}