@@ -74,12 +74,18 @@ mod custom_map {
7474 #![ allow( dead_code) ]
7575
7676 #[ allow( private_interfaces) ]
77- #[ derive( Debug , Clone , serde:: Serialize , serde:: Deserialize ) ]
77+ #[ derive( Debug , Clone , Default , serde:: Serialize , serde:: Deserialize ) ]
7878 pub struct CustomMap < K , V > {
7979 key : K ,
8080 value : V ,
8181 }
8282
83+ impl < K , V > CustomMap < K , V > {
84+ fn is_empty ( & self ) -> bool {
85+ false
86+ }
87+ }
88+
8389 include ! ( concat!( env!( "OUT_DIR" ) , "/codegen_custommap.rs" ) ) ;
8490
8591 #[ test]
@@ -93,3 +99,179 @@ mod custom_map {
9399 } ;
94100 }
95101}
102+
103+ // ========================================================================
104+ // Runtime serde integration tests for our fork fixes
105+ // ========================================================================
106+
107+ mod int_or_str {
108+ #![ allow( dead_code) ]
109+ include ! ( concat!( env!( "OUT_DIR" ) , "/codegen_int_or_str.rs" ) ) ;
110+ }
111+
112+ mod required_defaults {
113+ #![ allow( dead_code) ]
114+ include ! ( concat!( env!( "OUT_DIR" ) , "/codegen_required_defaults.rs" ) ) ;
115+ }
116+
117+ mod dscp {
118+ #![ allow( dead_code) ]
119+ include ! ( concat!( env!( "OUT_DIR" ) , "/codegen_dscp.rs" ) ) ;
120+ }
121+
122+ mod comparator {
123+ #![ allow( dead_code) ]
124+ include ! ( concat!( env!( "OUT_DIR" ) , "/codegen_comparator.rs" ) ) ;
125+ }
126+
127+ mod any_of_mixed {
128+ #![ allow( dead_code) ]
129+ include ! ( concat!( env!( "OUT_DIR" ) , "/codegen_any_of_mixed.rs" ) ) ;
130+ }
131+
132+ mod not_types {
133+ #![ allow( dead_code) ]
134+ include ! ( concat!( env!( "OUT_DIR" ) , "/codegen_not_types.rs" ) ) ;
135+ }
136+
137+ // --- PR #991: Integer before Number in untagged enums ---
138+
139+ #[ test]
140+ fn test_int_or_str_integer_deserialization ( ) {
141+ let v: int_or_str:: IntOrStr = serde_json:: from_str ( "42" ) . unwrap ( ) ;
142+ assert ! ( matches!( v, int_or_str:: IntOrStr :: Integer ( 42 ) ) ) ;
143+ }
144+
145+ #[ test]
146+ fn test_int_or_str_string_deserialization ( ) {
147+ let v: int_or_str:: IntOrStr = serde_json:: from_str ( r#""hello""# ) . unwrap ( ) ;
148+ assert ! ( matches!( v, int_or_str:: IntOrStr :: String ( _) ) ) ;
149+ }
150+
151+ #[ test]
152+ fn test_int_or_str_roundtrip ( ) {
153+ let original = int_or_str:: IntOrStr :: Integer ( 99 ) ;
154+ let json = serde_json:: to_string ( & original) . unwrap ( ) ;
155+ let back: int_or_str:: IntOrStr = serde_json:: from_str ( & json) . unwrap ( ) ;
156+ assert ! ( matches!( back, int_or_str:: IntOrStr :: Integer ( 99 ) ) ) ;
157+ }
158+
159+ // --- PR #918: Default impl for required fields with defaults ---
160+
161+ #[ test]
162+ fn test_required_with_defaults_default_impl ( ) {
163+ let d = required_defaults:: RequiredWithDefaults :: default ( ) ;
164+ assert_eq ! ( d. name, "unnamed" ) ;
165+ assert_eq ! ( d. count, 0 ) ;
166+ assert ! ( d. label. is_none( ) ) ;
167+ }
168+
169+ #[ test]
170+ fn test_required_with_defaults_deserialize_empty ( ) {
171+ let v: required_defaults:: RequiredWithDefaults = serde_json:: from_str ( "{}" ) . unwrap ( ) ;
172+ assert_eq ! ( v. name, "unnamed" ) ;
173+ assert_eq ! ( v. count, 0 ) ;
174+ }
175+
176+ #[ test]
177+ fn test_required_with_defaults_deserialize_partial ( ) {
178+ let v: required_defaults:: RequiredWithDefaults =
179+ serde_json:: from_str ( r#"{"name": "foo"}"# ) . unwrap ( ) ;
180+ assert_eq ! ( v. name, "foo" ) ;
181+ assert_eq ! ( v. count, 0 ) ;
182+ }
183+
184+ // --- PR #986: TryFrom for bounded integers ---
185+
186+ #[ test]
187+ fn test_dscp_try_from_valid ( ) {
188+ assert ! ( dscp:: Dscp :: try_from( 42u8 ) . is_ok( ) ) ;
189+ assert_eq ! ( * dscp:: Dscp :: try_from( 42u8 ) . unwrap( ) , 42 ) ;
190+ }
191+
192+ #[ test]
193+ fn test_dscp_try_from_boundary ( ) {
194+ assert ! ( dscp:: Dscp :: try_from( 0u8 ) . is_ok( ) ) ;
195+ assert ! ( dscp:: Dscp :: try_from( 63u8 ) . is_ok( ) ) ;
196+ assert ! ( dscp:: Dscp :: try_from( 64u8 ) . is_err( ) ) ;
197+ assert ! ( dscp:: Dscp :: try_from( 255u8 ) . is_err( ) ) ;
198+ }
199+
200+ #[ test]
201+ fn test_dscp_deserialize_valid ( ) {
202+ let d: dscp:: Dscp = serde_json:: from_str ( "42" ) . unwrap ( ) ;
203+ assert_eq ! ( * d, 42 ) ;
204+ }
205+
206+ #[ test]
207+ fn test_dscp_deserialize_out_of_range ( ) {
208+ assert ! ( serde_json:: from_str:: <dscp:: Dscp >( "64" ) . is_err( ) ) ;
209+ assert ! ( serde_json:: from_str:: <dscp:: Dscp >( "255" ) . is_err( ) ) ;
210+ }
211+
212+ // --- PR #948: Special char variant names ---
213+
214+ #[ test]
215+ fn test_comparator_deserialize ( ) {
216+ let v: comparator:: Comparator = serde_json:: from_str ( r#""=""# ) . unwrap ( ) ;
217+ assert ! ( matches!( v, comparator:: Comparator :: Eq ) ) ;
218+
219+ let v: comparator:: Comparator = serde_json:: from_str ( r#"">=""# ) . unwrap ( ) ;
220+ assert ! ( matches!( v, comparator:: Comparator :: GtEq ) ) ;
221+
222+ let v: comparator:: Comparator = serde_json:: from_str ( "\" ≥\" " ) . unwrap ( ) ;
223+ assert ! ( matches!( v, comparator:: Comparator :: Gte ) ) ;
224+
225+ let v: comparator:: Comparator = serde_json:: from_str ( "\" ≠\" " ) . unwrap ( ) ;
226+ assert ! ( matches!( v, comparator:: Comparator :: Neq ) ) ;
227+
228+ let v: comparator:: Comparator = serde_json:: from_str ( r#""!=""# ) . unwrap ( ) ;
229+ assert ! ( matches!( v, comparator:: Comparator :: BangEq ) ) ;
230+ }
231+
232+ #[ test]
233+ fn test_comparator_roundtrip ( ) {
234+ for json in [
235+ r#""=""# , r#"">""# , r#""<""# , "\" ≥\" " , r#"">=""# , "\" ≤\" " , r#""<=""# , "\" ≠\" " , r#""!=""# ,
236+ ] {
237+ let v: comparator:: Comparator = serde_json:: from_str ( json) . unwrap ( ) ;
238+ let back = serde_json:: to_string ( & v) . unwrap ( ) ;
239+ assert_eq ! ( json, back) ;
240+ }
241+ }
242+
243+ // --- PR #414: anyOf overhaul (no more panic on primitives) ---
244+
245+ #[ test]
246+ fn test_any_of_mixed_object ( ) {
247+ let v: any_of_mixed:: AnyOfMixed = serde_json:: from_str ( r#"{"value": "test"}"# ) . unwrap ( ) ;
248+ assert ! ( matches!( v, any_of_mixed:: AnyOfMixed :: Object { .. } ) ) ;
249+ }
250+
251+ #[ test]
252+ fn test_any_of_mixed_string ( ) {
253+ let v: any_of_mixed:: AnyOfMixed = serde_json:: from_str ( r#""hello""# ) . unwrap ( ) ;
254+ assert ! ( matches!( v, any_of_mixed:: AnyOfMixed :: String ( _) ) ) ;
255+ }
256+
257+ #[ test]
258+ fn test_any_of_mixed_integer ( ) {
259+ let v: any_of_mixed:: AnyOfMixed = serde_json:: from_str ( "42" ) . unwrap ( ) ;
260+ assert ! ( matches!( v, any_of_mixed:: AnyOfMixed :: Integer ( 42 ) ) ) ;
261+ }
262+
263+ // --- PR #954: not schema types don't panic ---
264+
265+ #[ test]
266+ fn test_not_object_accepts_primitives ( ) {
267+ // not: { type: "object" } falls back to serde_json::Value
268+ let _: not_types:: NotObject = serde_json:: from_str ( "42" ) . unwrap ( ) ;
269+ let _: not_types:: NotObject = serde_json:: from_str ( r#""hello""# ) . unwrap ( ) ;
270+ let _: not_types:: NotObject = serde_json:: from_str ( "true" ) . unwrap ( ) ;
271+ }
272+
273+ #[ test]
274+ fn test_array_non_objects ( ) {
275+ let v: not_types:: ArrayNonObjects = serde_json:: from_str ( r#"[1, "two", true]"# ) . unwrap ( ) ;
276+ assert_eq ! ( v. len( ) , 3 ) ;
277+ }
0 commit comments