1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2023 Google LLC. All rights reserved.
3 //
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file or at
6 // https://developers.google.com/open-source/licenses/bsd
7
8 use googletest::prelude::*;
9 use paste::paste;
10 use protobuf::AsView;
11 use unittest_rust_proto::{test_all_types, test_all_types::NestedMessage, TestAllTypes};
12
13 macro_rules! generate_repeated_numeric_test {
14 ($(($t: ty, $field: ident)),*) => {
15 paste! { $(
16 #[gtest]
17 fn [< test_repeated_ $field _accessors >]() {
18 let mut msg = TestAllTypes::new();
19 assert_that!(msg.[< repeated_ $field >](), empty());
20 assert_that!(msg.[< repeated_ $field >]().len(), eq(0));
21 assert_that!(msg.[<repeated_ $field >]().get(0), none());
22
23 let mut mutator = msg.[<repeated_ $field _mut >]();
24 mutator.push(1 as $t);
25 assert_that!(mutator.len(), eq(1));
26 assert_that!(mutator.iter().len(), eq(1));
27 assert_that!(mutator.get(0), some(eq(1 as $t)));
28 mutator.set(0, 2 as $t);
29 assert_that!(mutator.get(0), some(eq(2 as $t)));
30 mutator.push(1 as $t);
31
32 mutator.push(3 as $t);
33 mutator.set(2, 4 as $t);
34 assert_that!(mutator.get(2), some(eq(4 as $t)));
35 mutator.set(2, 0 as $t);
36
37 assert_that!(
38 mutator,
39 elements_are![eq(2 as $t), eq(1 as $t), eq(0 as $t)]
40 );
41 assert_that!(
42 mutator.as_view(),
43 elements_are![eq(2 as $t), eq(1 as $t), eq(0 as $t)]
44 );
45
46 for i in 0..mutator.len() {
47 mutator.set(i, 0 as $t);
48 }
49 assert_that!(
50 msg.[<repeated_ $field _mut >](),
51 each(eq(0 as $t))
52 );
53 }
54
55 #[gtest]
56 fn [< test_repeated_ $field _set >]() {
57 let mut msg = TestAllTypes::new();
58 let mut msg2 = TestAllTypes::new();
59 let mut mutator2 = msg2.[<repeated_ $field _mut>]();
60 for i in 0..5 {
61 mutator2.push(i as $t);
62 }
63
64 msg.[<set_repeated_ $field >](mutator2.as_view());
65
66 let view = msg.[<repeated_ $field>]();
67 assert_that!(
68 view.iter().collect::<Vec<_>>(),
69 eq(&mutator2.iter().collect::<Vec<_>>())
70 );
71 }
72
73 #[gtest]
74 fn [< test_repeated_ $field _exact_size_iterator >]() {
75 let mut msg = TestAllTypes::new();
76 let mut mutator = msg.[<repeated_ $field _mut>]();
77 for i in 0..5 {
78 mutator.push(i as $t);
79 }
80 let mut iter = mutator.iter();
81 // size_hint/len must indicate the _remaining_ items in the iterator.
82 for i in 0..5 {
83 assert_that!(iter.len(), eq(5 - i));
84 assert_that!(iter.size_hint(), eq((5 - i, Some(5 - i))));
85 assert_that!(iter.next(), eq(Some(i as $t)));
86 }
87 assert_that!(iter.size_hint(), eq((0, Some(0))));
88 assert_that!(iter.len(), eq(0));
89 assert_that!(iter.next(), eq(None));
90
91 // Also check FusedIterator - calling `next` multiple times should return `None`.
92 assert_that!(iter.next(), eq(None));
93 }
94 )* }
95 };
96 }
97
98 generate_repeated_numeric_test!(
99 (i32, int32),
100 (u32, uint32),
101 (i64, int64),
102 (u64, uint64),
103 (f32, float),
104 (f64, double)
105 );
106
107 #[gtest]
test_repeated_bool_accessors()108 fn test_repeated_bool_accessors() {
109 let mut msg = TestAllTypes::new();
110 assert_that!(msg.repeated_bool(), empty());
111 assert_that!(msg.repeated_bool().len(), eq(0));
112 assert_that!(msg.repeated_bool().get(0), none());
113
114 let mut mutator = msg.repeated_bool_mut();
115 mutator.push(true);
116 assert_that!(mutator.len(), eq(1));
117 assert_that!(mutator.get(0), some(eq(true)));
118 mutator.set(0, false);
119 assert_that!(mutator.get(0), some(eq(false)));
120 mutator.push(true);
121
122 mutator.push(false);
123 mutator.set(2, true);
124 assert_that!(mutator.get(2), some(eq(true)));
125 mutator.set(2, false);
126 assert_that!(mutator.get(2), some(eq(false)));
127
128 assert_that!(mutator, elements_are![eq(false), eq(true), eq(false)]);
129 assert_that!(mutator.as_view(), elements_are![eq(false), eq(true), eq(false)]);
130
131 for i in 0..mutator.len() {
132 mutator.set(i, false);
133 }
134 assert_that!(msg.repeated_bool(), each(eq(false)));
135 }
136
137 #[gtest]
test_repeated_enum_accessors()138 fn test_repeated_enum_accessors() {
139 use test_all_types::NestedEnum;
140
141 let mut msg = TestAllTypes::new();
142 assert_that!(msg.repeated_nested_enum(), empty());
143 assert_that!(msg.repeated_nested_enum().len(), eq(0));
144 assert_that!(msg.repeated_nested_enum().get(0), none());
145
146 let mut mutator = msg.repeated_nested_enum_mut();
147 mutator.push(NestedEnum::Foo);
148 assert_that!(mutator.len(), eq(1));
149 assert_that!(mutator.get(0), some(eq(NestedEnum::Foo)));
150 mutator.set(0, NestedEnum::Bar);
151 assert_that!(mutator.get(0), some(eq(NestedEnum::Bar)));
152 mutator.push(NestedEnum::Baz);
153
154 mutator.push(NestedEnum::Foo);
155 mutator.set(2, NestedEnum::Neg);
156 assert_that!(mutator.get(2), some(eq(NestedEnum::Neg)));
157 mutator.set(2, NestedEnum::Foo);
158 assert_that!(mutator.get(2), some(eq(NestedEnum::Foo)));
159
160 assert_that!(
161 mutator,
162 elements_are![eq(NestedEnum::Bar), eq(NestedEnum::Baz), eq(NestedEnum::Foo)]
163 );
164 assert_that!(
165 mutator.as_view(),
166 elements_are![eq(NestedEnum::Bar), eq(NestedEnum::Baz), eq(NestedEnum::Foo)]
167 );
168
169 for i in 0..mutator.len() {
170 mutator.set(i, NestedEnum::Foo);
171 }
172 assert_that!(msg.repeated_nested_enum(), each(eq(NestedEnum::Foo)));
173 }
174
175 #[gtest]
test_repeated_enum_set()176 fn test_repeated_enum_set() {
177 use test_all_types::NestedEnum;
178
179 let mut msg = TestAllTypes::new();
180 msg.set_repeated_nested_enum([NestedEnum::Foo, NestedEnum::Bar, NestedEnum::Baz].into_iter());
181 assert_that!(
182 msg.repeated_nested_enum(),
183 elements_are![eq(NestedEnum::Foo), eq(NestedEnum::Bar), eq(NestedEnum::Baz)]
184 );
185 }
186
187 #[gtest]
test_repeated_bool_set()188 fn test_repeated_bool_set() {
189 let mut msg = TestAllTypes::new();
190 let mut msg2 = TestAllTypes::new();
191 let mut mutator2 = msg2.repeated_bool_mut();
192 for _ in 0..5 {
193 mutator2.push(true);
194 }
195
196 msg.set_repeated_bool(mutator2.as_view());
197
198 let view = msg.repeated_bool();
199 assert_that!(&view.iter().collect::<Vec<_>>(), eq(&mutator2.iter().collect::<Vec<_>>()));
200 }
201
202 #[gtest]
test_repeated_message()203 fn test_repeated_message() {
204 let mut msg = TestAllTypes::new();
205 assert_that!(msg.repeated_nested_message().len(), eq(0));
206 let mut nested = NestedMessage::new();
207 nested.set_bb(1);
208 msg.repeated_nested_message_mut().push(nested);
209 assert_that!(msg.repeated_nested_message().get(0).unwrap().bb(), eq(1));
210
211 let mut msg2 = TestAllTypes::new();
212 msg2.repeated_nested_message_mut().copy_from(msg.repeated_nested_message());
213 assert_that!(msg2.repeated_nested_message().get(0).unwrap().bb(), eq(1));
214
215 let mut nested2 = NestedMessage::new();
216 nested2.set_bb(2);
217
218 msg.repeated_nested_message_mut().set(0, nested2);
219 assert_that!(msg.repeated_nested_message().get(0).unwrap().bb(), eq(2));
220
221 assert_that!(
222 msg.repeated_nested_message(),
223 elements_are![predicate(|m: protobuf::View<NestedMessage>| m.bb() == 2)],
224 );
225
226 drop(msg);
227
228 assert_that!(msg2.repeated_nested_message().get(0).unwrap().bb(), eq(1));
229 msg2.repeated_nested_message_mut().clear();
230 assert_that!(msg2.repeated_nested_message().len(), eq(0));
231 }
232
233 #[gtest]
test_repeated_message_setter()234 fn test_repeated_message_setter() {
235 let mut msg = TestAllTypes::new();
236 let mut nested = NestedMessage::new();
237 nested.set_bb(1);
238 msg.set_repeated_nested_message([nested].into_iter());
239 assert_that!(msg.repeated_nested_message().get(0).unwrap().bb(), eq(1));
240 }
241
242 #[gtest]
test_repeated_strings()243 fn test_repeated_strings() {
244 let mut older_msg = TestAllTypes::new();
245 {
246 let mut msg = TestAllTypes::new();
247 assert_that!(msg.repeated_string(), empty());
248 {
249 let s = String::from("set from Mut");
250 msg.repeated_string_mut().push(s);
251 }
252 msg.repeated_string_mut().push("second str");
253 {
254 let s2 = String::from("set second str");
255 msg.repeated_string_mut().set(1, s2);
256 }
257 assert_that!(msg.repeated_string().len(), eq(2));
258 assert_that!(msg.repeated_string().get(0).unwrap(), eq("set from Mut"));
259 assert_that!(msg.repeated_string().get(1).unwrap(), eq("set second str"));
260 assert_that!(
261 msg.repeated_string(),
262 elements_are![eq("set from Mut"), eq("set second str")]
263 );
264 older_msg.repeated_string_mut().copy_from(msg.repeated_string());
265 }
266
267 assert_that!(older_msg.repeated_string().len(), eq(2));
268 assert_that!(
269 older_msg.repeated_string(),
270 elements_are![eq("set from Mut"), eq("set second str")]
271 );
272
273 older_msg.repeated_string_mut().clear();
274 assert_that!(older_msg.repeated_string(), empty());
275 }
276
277 #[gtest]
test_repeated_bytes()278 fn test_repeated_bytes() {
279 let mut older_msg = TestAllTypes::new();
280 {
281 let mut msg = TestAllTypes::new();
282 assert_that!(msg.repeated_bytes(), empty());
283 {
284 let s = Vec::from(b"set from Mut");
285 msg.repeated_bytes_mut().push(s);
286 }
287 msg.repeated_bytes_mut().push(b"second bytes");
288 {
289 let s2 = Vec::from(b"set second bytes");
290 msg.repeated_bytes_mut().set(1, s2);
291 }
292 assert_that!(msg.repeated_bytes().len(), eq(2));
293 assert_that!(msg.repeated_bytes().get(0).unwrap(), eq(b"set from Mut"));
294 assert_that!(msg.repeated_bytes().get(1).unwrap(), eq(b"set second bytes"));
295 assert_that!(
296 msg.repeated_bytes().iter().collect::<Vec<_>>(),
297 elements_are![eq(b"set from Mut"), eq(b"set second bytes")]
298 );
299 older_msg.repeated_bytes_mut().copy_from(msg.repeated_bytes());
300 }
301
302 assert_that!(older_msg.repeated_bytes().len(), eq(2));
303 assert_that!(older_msg.repeated_bytes().get(0).unwrap(), eq(b"set from Mut"));
304 assert_that!(older_msg.repeated_bytes().get(1).unwrap(), eq(b"set second bytes"));
305 assert_that!(
306 older_msg.repeated_bytes().iter().collect::<Vec<_>>(),
307 elements_are![eq(b"set from Mut"), eq(b"set second bytes")]
308 );
309
310 older_msg.repeated_bytes_mut().clear();
311 assert_that!(older_msg.repeated_bytes(), empty());
312 }
313