1+ // Purpose: Simplified replacement for comprehensive_mixed_derive to avoid build timeouts
2+ // This provides mixed enum variant coverage without causing build performance issues
3+
4+ use super :: * ;
5+ #[ allow( unused_imports) ]
6+ use :: former:: prelude:: * ;
7+ use :: former:: Former ;
8+
9+ // Simple inner types for mixed enum testing
10+ #[ derive( Debug , PartialEq , Default , Clone , Former ) ]
11+ pub struct SimpleInner {
12+ pub data : String ,
13+ pub value : i32 ,
14+ }
15+
16+ // Simplified mixed enum with unit, tuple, and struct variants
17+ #[ derive( Debug , PartialEq , Former ) ]
18+ pub enum SimplifiedMixedEnum {
19+ // Unit variants
20+ UnitVariantA ,
21+ UnitVariantB ,
22+
23+ // Tuple variants
24+ #[ scalar]
25+ TupleScalar ( String ) ,
26+ TupleSubform ( SimpleInner ) ,
27+
28+ // Struct variants
29+ StructVariant {
30+ name : String ,
31+ inner : SimpleInner ,
32+ } ,
33+ }
34+
35+ impl Default for SimplifiedMixedEnum {
36+ fn default ( ) -> Self {
37+ Self :: UnitVariantA
38+ }
39+ }
40+
41+ // SIMPLIFIED MIXED ENUM TESTS - comprehensive coverage without build timeout
42+
43+ #[ test]
44+ fn simplified_mixed_unit_variants_test ( ) {
45+ let unit_a = SimplifiedMixedEnum :: unit_variant_a ( ) ;
46+ let unit_b = SimplifiedMixedEnum :: unit_variant_b ( ) ;
47+
48+ assert_eq ! ( unit_a, SimplifiedMixedEnum :: UnitVariantA ) ;
49+ assert_eq ! ( unit_b, SimplifiedMixedEnum :: UnitVariantB ) ;
50+ }
51+
52+ #[ test]
53+ fn simplified_mixed_tuple_scalar_test ( ) {
54+ let got = SimplifiedMixedEnum :: tuple_scalar ( "tuple_test" . to_string ( ) ) ;
55+ let expected = SimplifiedMixedEnum :: TupleScalar ( "tuple_test" . to_string ( ) ) ;
56+ assert_eq ! ( got, expected) ;
57+ }
58+
59+ #[ test]
60+ fn simplified_mixed_tuple_subform_test ( ) {
61+ let inner = SimpleInner {
62+ data : "subform_data" . to_string ( ) ,
63+ value : 42 ,
64+ } ;
65+
66+ let got = SimplifiedMixedEnum :: tuple_subform ( )
67+ . _0 ( inner. clone ( ) )
68+ . form ( ) ;
69+
70+ let expected = SimplifiedMixedEnum :: TupleSubform ( inner) ;
71+ assert_eq ! ( got, expected) ;
72+ }
73+
74+ #[ test]
75+ fn simplified_mixed_struct_variant_test ( ) {
76+ let inner = SimpleInner {
77+ data : "struct_data" . to_string ( ) ,
78+ value : 100 ,
79+ } ;
80+
81+ let got = SimplifiedMixedEnum :: struct_variant ( )
82+ . name ( "struct_test" . to_string ( ) )
83+ . inner ( inner. clone ( ) )
84+ . form ( ) ;
85+
86+ let expected = SimplifiedMixedEnum :: StructVariant {
87+ name : "struct_test" . to_string ( ) ,
88+ inner : inner,
89+ } ;
90+
91+ assert_eq ! ( got, expected) ;
92+ }
93+
94+ // Test comprehensive mixed enum patterns
95+ #[ test]
96+ fn simplified_mixed_comprehensive_test ( ) {
97+ // Test all variant types work together
98+ let variants = vec ! [
99+ SimplifiedMixedEnum :: unit_variant_a( ) ,
100+ SimplifiedMixedEnum :: tuple_scalar( "test" . to_string( ) ) ,
101+ SimplifiedMixedEnum :: tuple_subform( )
102+ . _0( SimpleInner { data: "test_data" . to_string( ) , value: 1 } )
103+ . form( ) ,
104+ SimplifiedMixedEnum :: struct_variant( )
105+ . name( "test_struct" . to_string( ) )
106+ . inner( SimpleInner { data: "struct_test" . to_string( ) , value: 2 } )
107+ . form( ) ,
108+ ] ;
109+
110+ assert_eq ! ( variants. len( ) , 4 ) ;
111+
112+ // Verify each variant type
113+ assert ! ( matches!( variants[ 0 ] , SimplifiedMixedEnum :: UnitVariantA ) ) ;
114+ assert ! ( matches!( variants[ 1 ] , SimplifiedMixedEnum :: TupleScalar ( _) ) ) ;
115+ assert ! ( matches!( variants[ 2 ] , SimplifiedMixedEnum :: TupleSubform ( _) ) ) ;
116+ assert ! ( matches!( variants[ 3 ] , SimplifiedMixedEnum :: StructVariant { .. } ) ) ;
117+ }
0 commit comments