Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(667)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: mojo/public/rust/tests/encoding.rs

Issue 2250183003: Make the fuchsia mojo/public repo the source of truth. (Closed) Base URL: https://github.com/domokit/mojo.git@master
Patch Set: Created 4 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « mojo/public/rust/src/system/wait_set.rs ('k') | mojo/public/rust/tests/integration.rs » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright 2016 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 //! Tests encoding and decoding functionality in the bindings package
6 //!
7 //! Test failure is defined as the function returning via panicking
8 //! and the result being caught in the test! macro. If a test function
9 //! returns without panicking, it is assumed to pass.
10
11 #[macro_use]
12 extern crate mojo;
13
14 use mojo::bindings::encoding::Context;
15 use mojo::bindings::message::MessageHeader;
16 use mojo::bindings::mojom::{MojomUnion, MojomPointer, MojomStruct, MojomInterfac e};
17
18 use mojo::system;
19 use mojo::system::Handle;
20
21 use std::collections::HashMap;
22
23 #[macro_use]
24 mod util;
25
26 use util::mojom_validation::*;
27
28 /// This macro is a wrapper for the tests! macro as it takes advantage of the
29 /// shared code between tests.
30 ///
31 /// Given a test name, it will generate a test function. In this test function
32 /// we perform the following steps:
33 /// 1. Decode the header of the validation input.
34 /// 2. Verify the decoded header is what we expect.
35 /// 3. Decode the payload of the validation input.
36 /// 4. Verify the decoded payload is what we expect.
37 /// 5. Take the decoded payload and re-encode.
38 /// 6. Decode this re-encoded payload.
39 /// 7. Verify the re-decoded payload is what we expect.
40 ///
41 /// Each test should sufficiently verify the operation of the encoding and decod ing
42 /// frameworks as we first verify the decoder works correctly on the "golden fil es",
43 /// then verify that the encoder works by encoding the decoded output, and decod ing
44 /// that once again.
45 macro_rules! encoding_tests {
46 ($($name:ident { MessageHeader => $header_cls:expr, $req_type:ident => $cls: expr } )*) => {
47 tests! {
48 $(
49 fn $name() {
50 let data = include_str!(concat!("../../interfaces/bindings/tests /data/validation/",
51 stringify!($name),
52 ".data"));
53 match util::parse_validation_test(data) {
54 Ok((mut data, num_handles)) => {
55 let mut mock_handles = Vec::with_capacity(num_handles);
56 for _ in 0..num_handles {
57 mock_handles.push(unsafe { system::acquire(0) });
58 }
59 println!("{}: Decoding header", stringify!($name));
60 let header = MessageHeader::deserialize(&mut data[..], V ec::new()).expect("Should not error");
61 let ctxt: Context = Default::default();
62 let header_size = header.serialized_size(&ctxt);
63 let header_cls = $header_cls;
64 println!("{}: Verifying decoded header", stringify!($nam e));
65 header_cls(header);
66 let payload_buffer = &mut data[header_size..];
67 let cls = $cls;
68 println!("{}: Decoding payload", stringify!($name));
69 let decoded_payload = $req_type::deserialize(payload_buf fer, mock_handles).expect("Should not error");
70 println!("{}: Verifying decoded payload", stringify!($na me));
71 cls(&decoded_payload);
72 println!("{}: Re-encoding payload", stringify!($name));
73 let (mut encoded_payload, handles) = decoded_payload.aut o_serialize();
74 println!("{}: Decoding payload again", stringify!($name) );
75 let redecoded_payload = $req_type::deserialize(&mut enco ded_payload[..], handles).expect("Should not error");
76 println!("{}: Verifying decoded payload again", stringif y!($name));
77 cls(&redecoded_payload);
78 },
79 Err(msg) => panic!("Error: {}", msg),
80 }
81 }
82 )*
83 }
84 }
85 }
86
87 encoding_tests! {
88 conformance_mthd0_good {
89 MessageHeader => {
90 |header: MessageHeader| {
91 assert_eq!(header.version, 0);
92 assert_eq!(header.name, 0);
93 assert_eq!(header.flags, 0);
94 }
95 },
96 ConformanceTestInterfaceMethod0Request => {
97 |payload: &ConformanceTestInterfaceMethod0Request| {
98 assert_eq!(payload.param0, -1.0);
99 }
100 }
101 }
102 conformance_mthd1_good {
103 MessageHeader => {
104 |header: MessageHeader| {
105 assert_eq!(header.version, 0);
106 assert_eq!(header.name, 1);
107 assert_eq!(header.flags, 0);
108 }
109 },
110 ConformanceTestInterfaceMethod1Request => {
111 |payload: &ConformanceTestInterfaceMethod1Request| {
112 assert_eq!(payload.param0.i, 1234);
113 }
114 }
115 }
116 conformance_mthd2_good {
117 MessageHeader => {
118 |header: MessageHeader| {
119 assert_eq!(header.version, 0);
120 assert_eq!(header.name, 2);
121 assert_eq!(header.flags, 0);
122 }
123 },
124 ConformanceTestInterfaceMethod2Request => {
125 |payload: &ConformanceTestInterfaceMethod2Request| {
126 assert_eq!(payload.param0.struct_a.i, 12345);
127 assert_eq!(payload.param1.i, 67890);
128 }
129 }
130 }
131 conformance_mthd3_good {
132 MessageHeader => {
133 |header: MessageHeader| {
134 assert_eq!(header.version, 0);
135 assert_eq!(header.name, 3);
136 assert_eq!(header.flags, 0);
137 }
138 },
139 ConformanceTestInterfaceMethod3Request => {
140 |payload: &ConformanceTestInterfaceMethod3Request| {
141 assert_eq!(payload.param0, vec![true, false, true, false,
142 true, false, true, false,
143 true, true, true, true]);
144 }
145 }
146 }
147 conformance_mthd4_good {
148 MessageHeader => {
149 |header: MessageHeader| {
150 assert_eq!(header.version, 0);
151 assert_eq!(header.name, 4);
152 assert_eq!(header.flags, 0);
153 }
154 },
155 ConformanceTestInterfaceMethod4Request => {
156 |payload: &ConformanceTestInterfaceMethod4Request| {
157 assert_eq!(payload.param0.data, vec![0, 1, 2]);
158 assert_eq!(payload.param1, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
159 }
160 }
161 }
162 conformance_mthd5_good {
163 MessageHeader => {
164 |header: MessageHeader| {
165 assert_eq!(header.version, 0);
166 assert_eq!(header.name, 5);
167 assert_eq!(header.flags, 0);
168 }
169 },
170 ConformanceTestInterfaceMethod5Request => {
171 |payload: &ConformanceTestInterfaceMethod5Request| {
172 assert_eq!(payload.param0.struct_d.message_pipes.len(), 2);
173 for h in payload.param0.struct_d.message_pipes.iter() {
174 assert_eq!(h.get_native_handle(), 0);
175 }
176 assert_eq!(payload.param0.data_pipe_consumer.get_native_handle() , 0);
177 assert_eq!(payload.param1.get_native_handle(), 0);
178 }
179 }
180 }
181 conformance_mthd6_good {
182 MessageHeader => {
183 |header: MessageHeader| {
184 assert_eq!(header.version, 0);
185 assert_eq!(header.name, 6);
186 assert_eq!(header.flags, 0);
187 }
188 },
189 ConformanceTestInterfaceMethod6Request => {
190 |payload: &ConformanceTestInterfaceMethod6Request| {
191 assert_eq!(payload.param0, vec![vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]);
192 }
193 }
194 }
195 conformance_mthd7_good {
196 MessageHeader => {
197 |header: MessageHeader| {
198 assert_eq!(header.version, 0);
199 assert_eq!(header.name, 7);
200 assert_eq!(header.flags, 0);
201 }
202 },
203 ConformanceTestInterfaceMethod7Request => {
204 |payload: &ConformanceTestInterfaceMethod7Request| {
205 assert_eq!(payload.param0.fixed_size_array, [0, 1, 2]);
206 assert_eq!(payload.param1, [None, Some([0, 1, 2])]);
207 }
208 }
209 }
210 conformance_mthd8_good {
211 MessageHeader => {
212 |header: MessageHeader| {
213 assert_eq!(header.version, 0);
214 assert_eq!(header.name, 8);
215 assert_eq!(header.flags, 0);
216 }
217 },
218 ConformanceTestInterfaceMethod8Request => {
219 |payload: &ConformanceTestInterfaceMethod8Request| {
220 assert_eq!(payload.param0,
221 vec![None, Some(vec![String::from_utf8(vec![0, 1, 2, 3, 4]). unwrap()]), None]);
222 }
223 }
224 }
225 conformance_mthd9_good {
226 MessageHeader => {
227 |header: MessageHeader| {
228 assert_eq!(header.version, 0);
229 assert_eq!(header.name, 9);
230 assert_eq!(header.flags, 0);
231 }
232 },
233 ConformanceTestInterfaceMethod9Request => {
234 |payload: &ConformanceTestInterfaceMethod9Request| {
235 assert!(payload.param0.is_some());
236 if let Some(ref v) = payload.param0 {
237 assert_eq!(v.len(), 2);
238 assert_eq!(v[0].len(), 2);
239 assert_eq!(v[1].len(), 3);
240 assert!(v[0][0].is_some());
241 assert!(v[0][1].is_none());
242 assert!(v[1][0].is_some());
243 assert!(v[1][1].is_none());
244 assert!(v[1][2].is_some());
245 assert_eq!(v[0][0].as_ref().unwrap().get_native_handle(), 0) ;
246 assert_eq!(v[1][0].as_ref().unwrap().get_native_handle(), 0) ;
247 assert_eq!(v[1][2].as_ref().unwrap().get_native_handle(), 0) ;
248 }
249 }
250 }
251 }
252 conformance_mthd9_good_null_array {
253 MessageHeader => {
254 |header: MessageHeader| {
255 assert_eq!(header.version, 0);
256 assert_eq!(header.name, 9);
257 assert_eq!(header.flags, 0);
258 }
259 },
260 ConformanceTestInterfaceMethod9Request => {
261 |payload: &ConformanceTestInterfaceMethod9Request| {
262 assert!(payload.param0.is_none());
263 }
264 }
265 }
266 conformance_mthd10_good {
267 MessageHeader => {
268 |header: MessageHeader| {
269 assert_eq!(header.version, 0);
270 assert_eq!(header.name, 10);
271 assert_eq!(header.flags, 0);
272 }
273 },
274 ConformanceTestInterfaceMethod10Request => {
275 |payload: &ConformanceTestInterfaceMethod10Request| {
276 let mut map = HashMap::with_capacity(2);
277 map.insert(String::from_utf8(vec![0, 1, 2, 3, 4]).unwrap(), 1);
278 map.insert(String::from_utf8(vec![5, 6, 7, 8, 9]).unwrap(), 2);
279 assert_eq!(payload.param0, map);
280 }
281 }
282 }
283 // Non-unique keys are strange...
284 // Right now, we handle them by silently overwriting.
285 // Maybe this will be an error in the future.
286 // The insert calls below reflect the duplicate keys that the
287 // test provides, and an example as to how overwriting happens.
288 conformance_mthd10_good_non_unique_keys {
289 MessageHeader => {
290 |header: MessageHeader| {
291 assert_eq!(header.version, 0);
292 assert_eq!(header.name, 10);
293 assert_eq!(header.flags, 0);
294 }
295 },
296 ConformanceTestInterfaceMethod10Request => {
297 |payload: &ConformanceTestInterfaceMethod10Request| {
298 let mut map = HashMap::with_capacity(2);
299 map.insert(String::from_utf8(vec![0, 1, 2, 3, 4]).unwrap(), 1);
300 map.insert(String::from_utf8(vec![0, 1, 2, 3, 4]).unwrap(), 2);
301 assert_eq!(payload.param0, map);
302 }
303 }
304 }
305 conformance_mthd11_good_version0 {
306 MessageHeader => {
307 |header: MessageHeader| {
308 assert_eq!(header.version, 0);
309 assert_eq!(header.name, 11);
310 assert_eq!(header.flags, 0);
311 }
312 },
313 ConformanceTestInterfaceMethod11Request => {
314 |payload: &ConformanceTestInterfaceMethod11Request| {
315 assert_eq!(payload.param0.i, 123);
316 assert_eq!(payload.param0.b, false);
317 assert!(payload.param0.struct_a.is_none());
318 assert!(payload.param0.str.is_none());
319 }
320 }
321 }
322 conformance_mthd11_good_version1 {
323 MessageHeader => {
324 |header: MessageHeader| {
325 assert_eq!(header.version, 0);
326 assert_eq!(header.name, 11);
327 assert_eq!(header.flags, 0);
328 }
329 },
330 ConformanceTestInterfaceMethod11Request => {
331 |payload: &ConformanceTestInterfaceMethod11Request| {
332 assert_eq!(payload.param0.i, 123);
333 assert_eq!(payload.param0.b, false);
334 assert!(payload.param0.struct_a.is_none());
335 assert!(payload.param0.str.is_none());
336 }
337 }
338 }
339 conformance_mthd11_good_version2 {
340 MessageHeader => {
341 |header: MessageHeader| {
342 assert_eq!(header.version, 0);
343 assert_eq!(header.name, 11);
344 assert_eq!(header.flags, 0);
345 }
346 },
347 ConformanceTestInterfaceMethod11Request => {
348 |payload: &ConformanceTestInterfaceMethod11Request| {
349 assert_eq!(payload.param0.i, 123);
350 assert_eq!(payload.param0.b, false);
351 assert!(payload.param0.struct_a.is_none());
352 assert!(payload.param0.str.is_none());
353 }
354 }
355 }
356 conformance_mthd11_good_version3 {
357 MessageHeader => {
358 |header: MessageHeader| {
359 assert_eq!(header.version, 0);
360 assert_eq!(header.name, 11);
361 assert_eq!(header.flags, 0);
362 }
363 },
364 ConformanceTestInterfaceMethod11Request => {
365 |payload: &ConformanceTestInterfaceMethod11Request| {
366 assert_eq!(payload.param0.i, 123);
367 assert_eq!(payload.param0.b, true);
368 assert!(payload.param0.struct_a.is_none());
369 assert_eq!(payload.param0.str, Some(String::from_utf8(vec![0, 1] ).unwrap()));
370 }
371 }
372 }
373 conformance_mthd11_good_version_newer_than_known_1 {
374 MessageHeader => {
375 |header: MessageHeader| {
376 assert_eq!(header.version, 0);
377 assert_eq!(header.name, 11);
378 assert_eq!(header.flags, 0);
379 }
380 },
381 ConformanceTestInterfaceMethod11Request => {
382 |payload: &ConformanceTestInterfaceMethod11Request| {
383 assert_eq!(payload.param0.i, 123);
384 assert_eq!(payload.param0.b, true);
385 assert!(payload.param0.struct_a.is_none());
386 assert_eq!(payload.param0.str, Some(String::from_utf8(vec![0, 1] ).unwrap()));
387 }
388 }
389 }
390 conformance_mthd11_good_version_newer_than_known_2 {
391 MessageHeader => {
392 |header: MessageHeader| {
393 assert_eq!(header.version, 0);
394 assert_eq!(header.name, 11);
395 assert_eq!(header.flags, 0);
396 }
397 },
398 ConformanceTestInterfaceMethod11Request => {
399 |payload: &ConformanceTestInterfaceMethod11Request| {
400 assert_eq!(payload.param0.i, 123);
401 assert_eq!(payload.param0.b, true);
402 assert!(payload.param0.struct_a.is_none());
403 assert_eq!(payload.param0.str, Some(String::from_utf8(vec![0, 1] ).unwrap()));
404 }
405 }
406 }
407 conformance_mthd13_good_1 {
408 MessageHeader => {
409 |header: MessageHeader| {
410 assert_eq!(header.version, 0);
411 assert_eq!(header.name, 13);
412 assert_eq!(header.flags, 0);
413 }
414 },
415 ConformanceTestInterfaceMethod13Request => {
416 |payload: &ConformanceTestInterfaceMethod13Request| {
417 assert!(payload.param0.is_none());
418 assert_eq!(payload.param1, 65535);
419 assert!(payload.param2.is_none());
420 }
421 }
422 }
423 conformance_mthd13_good_2 {
424 MessageHeader => {
425 |header: MessageHeader| {
426 assert_eq!(header.version, 0);
427 assert_eq!(header.name, 13);
428 assert_eq!(header.flags, 0);
429 }
430 },
431 ConformanceTestInterfaceMethod13Request => {
432 |payload: &ConformanceTestInterfaceMethod13Request| {
433 assert!(payload.param0.is_some());
434 assert_eq!(payload.param0.as_ref().unwrap().pipe().get_native_ha ndle(), 0);
435 assert_eq!(payload.param1, 65535);
436 assert!(payload.param2.is_some());
437 assert_eq!(payload.param2.as_ref().unwrap().pipe().get_native_ha ndle(), 0);
438 }
439 }
440 }
441 conformance_mthd14_good_1 {
442 MessageHeader => {
443 |header: MessageHeader| {
444 assert_eq!(header.version, 0);
445 assert_eq!(header.name, 14);
446 assert_eq!(header.flags, 0);
447 }
448 },
449 ConformanceTestInterfaceMethod14Request => {
450 |payload: &ConformanceTestInterfaceMethod14Request| {
451 match payload.param0 {
452 UnionA::a(ref val) => assert_eq!(*val, 54),
453 _ => panic!("Incorrect union variant! Tag found: {}", payloa d.param0.get_tag()),
454 }
455 }
456 }
457 }
458 conformance_mthd14_good_array_in_union {
459 MessageHeader => {
460 |header: MessageHeader| {
461 assert_eq!(header.version, 0);
462 assert_eq!(header.name, 14);
463 assert_eq!(header.flags, 0);
464 }
465 },
466 ConformanceTestInterfaceMethod14Request => {
467 |payload: &ConformanceTestInterfaceMethod14Request| {
468 match payload.param0 {
469 UnionA::d(ref val) => assert_eq!(*val, Some(vec![0, 1, 2])),
470 _ => panic!("Incorrect union variant! Tag found: {}", payloa d.param0.get_tag()),
471 }
472 }
473 }
474 }
475 conformance_mthd14_good_map_in_union {
476 MessageHeader => {
477 |header: MessageHeader| {
478 assert_eq!(header.version, 0);
479 assert_eq!(header.name, 14);
480 assert_eq!(header.flags, 0);
481 }
482 },
483 ConformanceTestInterfaceMethod14Request => {
484 |payload: &ConformanceTestInterfaceMethod14Request| {
485 let mut map = HashMap::with_capacity(2);
486 map.insert(String::from_utf8(vec![0, 1, 2, 3, 4]).unwrap(), 1);
487 map.insert(String::from_utf8(vec![5, 6, 7, 8, 9]).unwrap(), 2);
488 match payload.param0 {
489 UnionA::e(ref val) => assert_eq!(*val, Some(map)),
490 _ => panic!("Incorrect union variant! Tag found: {}", payloa d.param0.get_tag()),
491 }
492 }
493 }
494 }
495 conformance_mthd14_good_nested_union {
496 MessageHeader => {
497 |header: MessageHeader| {
498 assert_eq!(header.version, 0);
499 assert_eq!(header.name, 14);
500 assert_eq!(header.flags, 0);
501 }
502 },
503 ConformanceTestInterfaceMethod14Request => {
504 |payload: &ConformanceTestInterfaceMethod14Request| {
505 match payload.param0 {
506 UnionA::f(ref val) => {
507 assert!(val.is_some());
508 let inner = val.as_ref().unwrap();
509 match *inner {
510 UnionB::b(inner_val) => assert_eq!(inner_val, 10),
511 _ => panic!("Incorrect inner union variant! Tag foun d: {}", inner.get_tag()),
512 }
513 },
514 _ => panic!("Incorrect union variant! Tag found: {}", payloa d.param0.get_tag()),
515 }
516 }
517 }
518 }
519 conformance_mthd14_good_null_array_in_union {
520 MessageHeader => {
521 |header: MessageHeader| {
522 assert_eq!(header.version, 0);
523 assert_eq!(header.name, 14);
524 assert_eq!(header.flags, 0);
525 }
526 },
527 ConformanceTestInterfaceMethod14Request => {
528 |payload: &ConformanceTestInterfaceMethod14Request| {
529 match payload.param0 {
530 UnionA::d(ref val) => assert_eq!(*val, None),
531 _ => panic!("Incorrect union variant! Tag found: {}", payloa d.param0.get_tag()),
532 }
533 }
534 }
535 }
536 conformance_mthd14_good_null_map_in_union {
537 MessageHeader => {
538 |header: MessageHeader| {
539 assert_eq!(header.version, 0);
540 assert_eq!(header.name, 14);
541 assert_eq!(header.flags, 0);
542 }
543 },
544 ConformanceTestInterfaceMethod14Request => {
545 |payload: &ConformanceTestInterfaceMethod14Request| {
546 match payload.param0 {
547 UnionA::e(ref val) => assert_eq!(*val, None),
548 _ => panic!("Incorrect union variant! Tag found: {}", payloa d.param0.get_tag()),
549 }
550 }
551 }
552 }
553 conformance_mthd14_good_struct_in_union {
554 MessageHeader => {
555 |header: MessageHeader| {
556 assert_eq!(header.version, 0);
557 assert_eq!(header.name, 14);
558 assert_eq!(header.flags, 0);
559 }
560 },
561 ConformanceTestInterfaceMethod14Request => {
562 |payload: &ConformanceTestInterfaceMethod14Request| {
563 match payload.param0 {
564 UnionA::c(ref val) => {
565 let struct_val = val.as_ref().unwrap();
566 assert_eq!(struct_val.i, 20);
567 },
568 _ => panic!("Incorrect union variant! Tag found: {}", payloa d.param0.get_tag()),
569 }
570 }
571 }
572 }
573 conformance_mthd14_good_unknown_union_tag {
574 MessageHeader => {
575 |header: MessageHeader| {
576 assert_eq!(header.version, 0);
577 assert_eq!(header.name, 14);
578 assert_eq!(header.flags, 0);
579 }
580 },
581 ConformanceTestInterfaceMethod14Request => {
582 |payload: &ConformanceTestInterfaceMethod14Request| {
583 match payload.param0 {
584 UnionA::_Unknown(ref val) => assert_eq!(*val, 54),
585 _ => panic!("Incorrect union variant! Tag found: {}", payloa d.param0.get_tag()),
586 }
587 }
588 }
589 }
590 conformance_mthd15_good_union_in_array {
591 MessageHeader => {
592 |header: MessageHeader| {
593 assert_eq!(header.version, 0);
594 assert_eq!(header.name, 15);
595 assert_eq!(header.flags, 0);
596 }
597 },
598 ConformanceTestInterfaceMethod15Request => {
599 |payload: &ConformanceTestInterfaceMethod15Request| {
600 assert_eq!(payload.param0.a, true);
601 assert_eq!(payload.param0.b, 22);
602 assert!(payload.param0.c.is_none());
603 assert!(payload.param0.d.is_some());
604 assert!(payload.param0.e.is_none());
605 let array = payload.param0.d.as_ref().unwrap();
606 assert_eq!(array.len(), 3);
607 for u in array.iter() {
608 match *u {
609 UnionA::b(ref val) => assert_eq!(*val, 10),
610 _ => panic!("Incorrect union variant! Tag found: {}", u. get_tag()),
611 }
612 }
613 }
614 }
615 }
616 conformance_mthd15_good_union_in_map {
617 MessageHeader => {
618 |header: MessageHeader| {
619 assert_eq!(header.version, 0);
620 assert_eq!(header.name, 15);
621 assert_eq!(header.flags, 0);
622 }
623 },
624 ConformanceTestInterfaceMethod15Request => {
625 |payload: &ConformanceTestInterfaceMethod15Request| {
626 assert_eq!(payload.param0.a, true);
627 assert_eq!(payload.param0.b, 22);
628 assert!(payload.param0.c.is_none());
629 assert!(payload.param0.d.is_none());
630 assert!(payload.param0.e.is_some());
631 let map = payload.param0.e.as_ref().unwrap();
632 assert_eq!(map.len(), 3);
633 let mut expect_keys = HashMap::with_capacity(3);
634 expect_keys.insert(8, false);
635 expect_keys.insert(7, false);
636 expect_keys.insert(1, false);
637 for (key, value) in map.iter() {
638 expect_keys.insert(*key, true);
639 match *value {
640 UnionA::b(ref val) => assert_eq!(*val, 10),
641 _ => panic!("Incorrect union variant! Tag found: {}", va lue.get_tag()),
642 }
643 }
644 for (key, value) in expect_keys.iter() {
645 if *value == false {
646 panic!("Expected key `{}`, but not found!", *key);
647 }
648 }
649 }
650 }
651 }
652 conformance_mthd15_good_union_in_struct {
653 MessageHeader => {
654 |header: MessageHeader| {
655 assert_eq!(header.version, 0);
656 assert_eq!(header.name, 15);
657 assert_eq!(header.flags, 0);
658 }
659 },
660 ConformanceTestInterfaceMethod15Request => {
661 |payload: &ConformanceTestInterfaceMethod15Request| {
662 assert_eq!(payload.param0.a, true);
663 assert_eq!(payload.param0.b, 22);
664 assert!(payload.param0.c.is_some());
665 assert!(payload.param0.d.is_none());
666 assert!(payload.param0.e.is_none());
667 let union_val = payload.param0.c.as_ref().unwrap();
668 match *union_val {
669 UnionA::b(ref val) => assert_eq!(*val, 54),
670 _ => panic!("Incorrect union variant! Tag found: {}", union_ val.get_tag()),
671 }
672 }
673 }
674 }
675 integration_intf_rqst_mthd0_good {
676 MessageHeader => {
677 |header: MessageHeader| {
678 assert_eq!(header.version, 1);
679 assert_eq!(header.name, 0);
680 assert_eq!(header.flags, 1);
681 assert_eq!(header.request_id, 7);
682 }
683 },
684 IntegrationTestInterfaceMethod0Request => {
685 |payload: &IntegrationTestInterfaceMethod0Request| {
686 assert_eq!(payload.param0.a, -1);
687 }
688 }
689 }
690 integration_intf_resp_mthd0_good {
691 MessageHeader => {
692 |header: MessageHeader| {
693 assert_eq!(header.version, 1);
694 assert_eq!(header.name, 0);
695 assert_eq!(header.flags, 2);
696 assert_eq!(header.request_id, 1);
697 }
698 },
699 IntegrationTestInterfaceMethod0Response => {
700 |payload: &IntegrationTestInterfaceMethod0Response| {
701 assert_eq!(payload.param0, vec![0]);
702 }
703 }
704 }
705 }
OLDNEW
« no previous file with comments | « mojo/public/rust/src/system/wait_set.rs ('k') | mojo/public/rust/tests/integration.rs » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698