1 #[allow(dead_code, unused_imports)]
2 #[path = "../../optional_scalars_generated.rs"]
3 mod optional_scalars_generated;
4 use crate::optional_scalars_generated::optional_scalars::*;
5
6 // There are 3 variants of scalars in tables - those specified with default=42,
7 // optional scalars, and those with nothing specified (implicitly default=0).
8 // This tests that you can read what you write.
9 macro_rules! make_test {
10 (
11 $test_name: ident,
12 $just: ident, $default: ident, $maybe: ident,
13 $five: expr, $zero: expr, $fortytwo: expr
14 ) => {
15 #[test]
16 fn $test_name() {
17 let mut builder = flatbuffers::FlatBufferBuilder::new();
18 // Test five makes sense when specified.
19 let ss = ScalarStuff::create(
20 &mut builder,
21 &ScalarStuffArgs {
22 $just: $five,
23 $default: $five,
24 $maybe: Some($five),
25 ..Default::default()
26 },
27 );
28 builder.finish(ss, None);
29
30 let s = flatbuffers::root::<ScalarStuff>(builder.finished_data()).unwrap();
31 assert_eq!(s.$just(), $five);
32 assert_eq!(s.$default(), $five);
33 assert_eq!(s.$maybe(), Some($five));
34
35 // Test defaults are used when not specified.
36 let s = flatbuffers::root::<ScalarStuff>(&[0; 8]).unwrap();
37 assert_eq!(s.$just(), $zero);
38 assert_eq!(s.$default(), $fortytwo);
39 assert_eq!(s.$maybe(), None);
40
41 // Same for object API
42 let s = flatbuffers::root::<ScalarStuff>(builder.finished_data()).unwrap().unpack();
43 assert_eq!(s.$just, $five);
44 assert_eq!(s.$default, $five);
45 assert_eq!(s.$maybe, Some($five));
46 let s = flatbuffers::root::<ScalarStuff>(&[0; 8]).unwrap().unpack();
47 assert_eq!(s.$just, $zero);
48 assert_eq!(s.$default, $fortytwo);
49 assert_eq!(s.$maybe, None);
50 }
51 };
52 }
53
54 make_test!(optional_i8, just_i8, default_i8, maybe_i8, 5, 0, 42);
55 make_test!(optional_u8, just_u8, default_u8, maybe_u8, 5, 0, 42);
56 make_test!(optional_i16, just_i16, default_i16, maybe_i16, 5, 0, 42);
57 make_test!(optional_u16, just_u16, default_u16, maybe_u16, 5, 0, 42);
58 make_test!(optional_i32, just_i32, default_i32, maybe_i32, 5, 0, 42);
59 make_test!(optional_u32, just_u32, default_u32, maybe_u32, 5, 0, 42);
60 make_test!(optional_i64, just_i64, default_i64, maybe_i64, 5, 0, 42);
61 make_test!(optional_u64, just_u64, default_u64, maybe_u64, 5, 0, 42);
62 make_test!(
63 optional_f32,
64 just_f32,
65 default_f32,
66 maybe_f32,
67 5.0,
68 0.0,
69 42.0
70 );
71 make_test!(
72 optional_f64,
73 just_f64,
74 default_f64,
75 maybe_f64,
76 5.0,
77 0.0,
78 42.0
79 );
80 make_test!(
81 optional_bool,
82 just_bool,
83 default_bool,
84 maybe_bool,
85 true,
86 false,
87 true
88 );
89 make_test!(
90 optional_enum,
91 just_enum,
92 default_enum,
93 maybe_enum,
94 OptionalByte::Two,
95 OptionalByte::None,
96 OptionalByte::One
97 );
98
99 #[test]
object_api_defaults()100 fn object_api_defaults() {
101 assert_eq!(
102 ScalarStuffT::default(),
103 ScalarStuffT {
104 just_i8: 0,
105 maybe_i8: None,
106 default_i8: 42,
107 just_u8: 0,
108 maybe_u8: None,
109 default_u8: 42,
110
111 just_i16: 0,
112 maybe_i16: None,
113 default_i16: 42,
114 just_u16: 0,
115 maybe_u16: None,
116 default_u16: 42,
117
118 just_i32: 0,
119 maybe_i32: None,
120 default_i32: 42,
121 just_u32: 0,
122 maybe_u32: None,
123 default_u32: 42,
124
125 just_i64: 0,
126 maybe_i64: None,
127 default_i64: 42,
128 just_u64: 0,
129 maybe_u64: None,
130 default_u64: 42,
131
132 just_f32: 0.0,
133 maybe_f32: None,
134 default_f32: 42.0,
135 just_f64: 0.0,
136 maybe_f64: None,
137 default_f64: 42.0,
138
139 just_bool: false,
140 maybe_bool: None,
141 default_bool: true,
142
143 just_enum: OptionalByte::None,
144 maybe_enum: None,
145 default_enum: OptionalByte::One,
146
147 }
148 );
149 }
150