Rust: Add validation to decode

mojo/public/rust/tests/encoding.rs

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 //! Tests encoding and decoding functionality in the bindings package
 //!
 //! Test failure is defined as the function returning via panicking
 //! and the result being caught in the test! macro. If a test function
 //! returns without panicking, it is assumed to pass.
 
@@ skipping 39 matching lines @@
                 let data = include_str!(concat!("../../interfaces/bindings/tests/data/validation/",
                                                 stringify!($name),
                                                 ".data"));
                 match util::parse_validation_test(data) {
                     Ok((mut data, num_handles)) => {
                         let mut mock_handles = Vec::with_capacity(num_handles);
                         for _ in 0..num_handles {
                             mock_handles.push(unsafe { system::acquire(0) });
                         }
                         println!("{}: Decoding header", stringify!($name));
-                        let header = MessageHeader::deserialize(&mut data[..], Vec::new());
+                        let header = MessageHeader::deserialize(&mut data[..], Vec::new()).expect("Should not error");
                         let ctxt: Context = Default::default();
                         let header_size = header.serialized_size(&ctxt);
                         let header_cls = $header_cls;
                         println!("{}: Verifying decoded header", stringify!($name));
                         header_cls(header);
                         let payload_buffer = &mut data[header_size..];
                         let cls = $cls;
                         println!("{}: Decoding payload", stringify!($name));
-                        let decoded_payload = $req_type::deserialize(payload_buffer, mock_handles);
+                        let decoded_payload = $req_type::deserialize(payload_buffer, mock_handles).expect("Should not error");
                         println!("{}: Verifying decoded payload", stringify!($name));
                         cls(&decoded_payload);
                         println!("{}: Re-encoding payload", stringify!($name));
                         let (mut encoded_payload, handles) = decoded_payload.auto_serialize();
                         println!("{}: Decoding payload again", stringify!($name));
-                        let redecoded_payload = $req_type::deserialize(&mut encoded_payload[..], handles);
+                        let redecoded_payload = $req_type::deserialize(&mut encoded_payload[..], handles).expect("Should not error");
                         println!("{}: Verifying decoded payload again", stringify!($name));
                         cls(&redecoded_payload);
                     },
                     Err(msg) => panic!("Error: {}", msg),
                 }
             }
             )*
         }
     }
 }
@@ skipping 580 matching lines @@
                 assert!(payload.param0.e.is_none());
                 let union_val = payload.param0.c.as_ref().unwrap();
                 match *union_val {
                     UnionA::b(ref val) => assert_eq!(*val, 54),
                     _ => panic!("Incorrect union variant! Tag found: {}", union_val.get_tag()),
                 }
             }
         }
     }
 }