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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: mojo/public/rust/tests/encoding.rs

Issue 2213563002: Rust: Add encoder/decoder tests (Closed) Base URL: git@github.com:domokit/mojo.git@decoding
Patch Set: Test with changes 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 side-by-side diff with in-line comments
Download patch
« no previous file with comments | « mojo/public/rust/build.rs ('k') | mojo/public/rust/tests/util/mod.rs » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: mojo/public/rust/tests/encoding.rs
diff --git a/mojo/public/rust/tests/encoding.rs b/mojo/public/rust/tests/encoding.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e315bec4a55fdf54b6e3f7248e5892eb34752819
--- /dev/null
+++ b/mojo/public/rust/tests/encoding.rs
@@ -0,0 +1,675 @@
+// 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.
+
+#[macro_use]
+extern crate mojo;
+
+use mojo::bindings::encoding::Context;
+use mojo::bindings::message::MessageHeader;
+use mojo::bindings::mojom::{MojomUnion, MojomPointer, MojomStruct, MojomInterface};
+
+use mojo::system;
+use mojo::system::Handle;
+
+use std::collections::HashMap;
+
+#[macro_use]
+mod util;
+
+use util::mojom_validation::*;
+
+/// This macro is a wrapper for the tests! macro as it takes advantage of the
+/// shared code between tests.
+///
+/// Given a test name, it will generate a test function. In this test function
+/// we perform the following steps:
+/// 1. Decode the header of the validation input.
+/// 2. Verify the decoded header is what we expect.
+/// 3. Decode the payload of the validation input.
+/// 4. Verify the decoded payload is what we expect.
+/// 5. Take the decoded payload and re-encode.
+/// 6. Decode this re-encoded payload.
+/// 7. Verify the re-decoded payload is what we expect.
+///
+/// Each test should sufficiently verify the operation of the encoding and decoding
+/// frameworks as we first verify the decoder works correctly on the "golden files",
+/// then verify that the encoder works by encoding the decoded output, and decoding
+/// that once again.
+macro_rules! encoding_tests {
+ ($($name:ident { MessageHeader => $header_cls:expr, $req_type:ident => $cls:expr } )*) => {
+ tests! {
+ $(
+ fn $name() {
+ 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 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);
+ 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);
+ println!("{}: Verifying decoded payload again", stringify!($name));
+ cls(&redecoded_payload);
+ },
+ Err(msg) => panic!("Error: {}", msg),
+ }
+ }
+ )*
+ }
+ }
+}
+
+encoding_tests! {
+ conformance_mthd0_good {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 0);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod0Request => {
+ |payload: &ConformanceTestInterfaceMethod0Request| {
+ assert_eq!(payload.param0, -1.0);
+ }
+ }
+ }
+ conformance_mthd1_good {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 1);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod1Request => {
+ |payload: &ConformanceTestInterfaceMethod1Request| {
+ assert_eq!(payload.param0.i, 1234);
+ }
+ }
+ }
+ conformance_mthd2_good {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 2);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod2Request => {
+ |payload: &ConformanceTestInterfaceMethod2Request| {
+ assert_eq!(payload.param0.struct_a.i, 12345);
+ assert_eq!(payload.param1.i, 67890);
+ }
+ }
+ }
+ conformance_mthd3_good {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 3);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod3Request => {
+ |payload: &ConformanceTestInterfaceMethod3Request| {
+ assert_eq!(payload.param0, vec![true, false, true, false,
+ true, false, true, false,
+ true, true, true, true]);
+ }
+ }
+ }
+ conformance_mthd4_good {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 4);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod4Request => {
+ |payload: &ConformanceTestInterfaceMethod4Request| {
+ assert_eq!(payload.param0.data, vec![0, 1, 2]);
+ assert_eq!(payload.param1, vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+ }
+ }
+ }
+ conformance_mthd5_good {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 5);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod5Request => {
+ |payload: &ConformanceTestInterfaceMethod5Request| {
+ assert_eq!(payload.param0.struct_d.message_pipes.len(), 2);
+ for h in payload.param0.struct_d.message_pipes.iter() {
+ assert_eq!(h.get_native_handle(), 0);
+ }
+ assert_eq!(payload.param0.data_pipe_consumer.get_native_handle(), 0);
+ assert_eq!(payload.param1.get_native_handle(), 0);
+ }
+ }
+ }
+ conformance_mthd6_good {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 6);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod6Request => {
+ |payload: &ConformanceTestInterfaceMethod6Request| {
+ assert_eq!(payload.param0, vec![vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]);
+ }
+ }
+ }
+ conformance_mthd7_good {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 7);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod7Request => {
+ |payload: &ConformanceTestInterfaceMethod7Request| {
+ assert_eq!(payload.param0.fixed_size_array, [0, 1, 2]);
+ assert_eq!(payload.param1, [None, Some([0, 1, 2])]);
+ }
+ }
+ }
+ conformance_mthd8_good {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 8);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod8Request => {
+ |payload: &ConformanceTestInterfaceMethod8Request| {
+ assert_eq!(payload.param0,
+ vec![None, Some(vec![String::from_utf8(vec![0, 1, 2, 3, 4]).unwrap()]), None]);
+ }
+ }
+ }
+ conformance_mthd9_good {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 9);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod9Request => {
+ |payload: &ConformanceTestInterfaceMethod9Request| {
+ assert!(payload.param0.is_some());
+ if let Some(ref v) = payload.param0 {
+ assert_eq!(v.len(), 2);
+ assert_eq!(v[0].len(), 2);
+ assert_eq!(v[1].len(), 3);
+ assert!(v[0][0].is_some());
+ assert!(v[0][1].is_none());
+ assert!(v[1][0].is_some());
+ assert!(v[1][1].is_none());
+ assert!(v[1][2].is_some());
+ assert_eq!(v[0][0].as_ref().unwrap().get_native_handle(), 0);
+ assert_eq!(v[1][0].as_ref().unwrap().get_native_handle(), 0);
+ assert_eq!(v[1][2].as_ref().unwrap().get_native_handle(), 0);
+ }
+ }
+ }
+ }
+ conformance_mthd9_good_null_array {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 9);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod9Request => {
+ |payload: &ConformanceTestInterfaceMethod9Request| {
+ assert!(payload.param0.is_none());
+ }
+ }
+ }
+ conformance_mthd10_good {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 10);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod10Request => {
+ |payload: &ConformanceTestInterfaceMethod10Request| {
+ let mut map = HashMap::with_capacity(2);
+ map.insert(String::from_utf8(vec![0, 1, 2, 3, 4]).unwrap(), 1);
+ map.insert(String::from_utf8(vec![5, 6, 7, 8, 9]).unwrap(), 2);
+ assert_eq!(payload.param0, map);
+ }
+ }
+ }
+ // Non-unique keys are strange...
+ // Right now, we handle them by silently overwriting.
+ // Maybe this will be an error in the future.
+ // The insert calls below reflect the duplicate keys that the
+ // test provides, and an example as to how overwriting happens.
+ conformance_mthd10_good_non_unique_keys {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 10);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod10Request => {
+ |payload: &ConformanceTestInterfaceMethod10Request| {
+ let mut map = HashMap::with_capacity(2);
+ map.insert(String::from_utf8(vec![0, 1, 2, 3, 4]).unwrap(), 1);
+ map.insert(String::from_utf8(vec![0, 1, 2, 3, 4]).unwrap(), 2);
+ assert_eq!(payload.param0, map);
+ }
+ }
+ }
+ conformance_mthd11_good_version0 {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 11);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod11Request => {
+ |payload: &ConformanceTestInterfaceMethod11Request| {
+ assert_eq!(payload.param0.i, 123);
+ assert_eq!(payload.param0.b, false);
+ assert!(payload.param0.struct_a.is_none());
+ assert!(payload.param0.str.is_none());
+ }
+ }
+ }
+ conformance_mthd11_good_version1 {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 11);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod11Request => {
+ |payload: &ConformanceTestInterfaceMethod11Request| {
+ assert_eq!(payload.param0.i, 123);
+ assert_eq!(payload.param0.b, false);
+ assert!(payload.param0.struct_a.is_none());
+ assert!(payload.param0.str.is_none());
+ }
+ }
+ }
+ conformance_mthd11_good_version2 {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 11);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod11Request => {
+ |payload: &ConformanceTestInterfaceMethod11Request| {
+ assert_eq!(payload.param0.i, 123);
+ assert_eq!(payload.param0.b, false);
+ assert!(payload.param0.struct_a.is_none());
+ assert!(payload.param0.str.is_none());
+ }
+ }
+ }
+ conformance_mthd11_good_version3 {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 11);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod11Request => {
+ |payload: &ConformanceTestInterfaceMethod11Request| {
+ assert_eq!(payload.param0.i, 123);
+ assert_eq!(payload.param0.b, true);
+ assert!(payload.param0.struct_a.is_none());
+ assert_eq!(payload.param0.str, Some(String::from_utf8(vec![0, 1]).unwrap()));
+ }
+ }
+ }
+ conformance_mthd11_good_version_newer_than_known_1 {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 11);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod11Request => {
+ |payload: &ConformanceTestInterfaceMethod11Request| {
+ assert_eq!(payload.param0.i, 123);
+ assert_eq!(payload.param0.b, true);
+ assert!(payload.param0.struct_a.is_none());
+ assert_eq!(payload.param0.str, Some(String::from_utf8(vec![0, 1]).unwrap()));
+ }
+ }
+ }
+ conformance_mthd11_good_version_newer_than_known_2 {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 11);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod11Request => {
+ |payload: &ConformanceTestInterfaceMethod11Request| {
+ assert_eq!(payload.param0.i, 123);
+ assert_eq!(payload.param0.b, true);
+ assert!(payload.param0.struct_a.is_none());
+ assert_eq!(payload.param0.str, Some(String::from_utf8(vec![0, 1]).unwrap()));
+ }
+ }
+ }
+ conformance_mthd13_good_1 {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 13);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod13Request => {
+ |payload: &ConformanceTestInterfaceMethod13Request| {
+ assert!(payload.param0.is_none());
+ assert_eq!(payload.param1, 65535);
+ assert!(payload.param2.is_none());
+ }
+ }
+ }
+ conformance_mthd13_good_2 {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 13);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod13Request => {
+ |payload: &ConformanceTestInterfaceMethod13Request| {
+ assert!(payload.param0.is_some());
+ assert_eq!(payload.param0.as_ref().unwrap().pipe().get_native_handle(), 0);
+ assert_eq!(payload.param1, 65535);
+ assert!(payload.param2.is_some());
+ assert_eq!(payload.param2.as_ref().unwrap().pipe().get_native_handle(), 0);
+ }
+ }
+ }
+ conformance_mthd14_good_1 {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 14);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod14Request => {
+ |payload: &ConformanceTestInterfaceMethod14Request| {
+ match payload.param0 {
+ UnionA::a(ref val) => assert_eq!(*val, 54),
+ _ => panic!("Incorrect union variant! Tag found: {}", payload.param0.get_tag()),
+ }
+ }
+ }
+ }
+ conformance_mthd14_good_array_in_union {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 14);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod14Request => {
+ |payload: &ConformanceTestInterfaceMethod14Request| {
+ match payload.param0 {
+ UnionA::d(ref val) => assert_eq!(*val, Some(vec![0, 1, 2])),
+ _ => panic!("Incorrect union variant! Tag found: {}", payload.param0.get_tag()),
+ }
+ }
+ }
+ }
+ conformance_mthd14_good_map_in_union {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 14);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod14Request => {
+ |payload: &ConformanceTestInterfaceMethod14Request| {
+ let mut map = HashMap::with_capacity(2);
+ map.insert(String::from_utf8(vec![0, 1, 2, 3, 4]).unwrap(), 1);
+ map.insert(String::from_utf8(vec![5, 6, 7, 8, 9]).unwrap(), 2);
+ match payload.param0 {
+ UnionA::e(ref val) => assert_eq!(*val, Some(map)),
+ _ => panic!("Incorrect union variant! Tag found: {}", payload.param0.get_tag()),
+ }
+ }
+ }
+ }
+ conformance_mthd14_good_nested_union {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 14);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod14Request => {
+ |payload: &ConformanceTestInterfaceMethod14Request| {
+ match payload.param0 {
+ UnionA::f(ref val) => {
+ assert!(val.is_some());
+ let inner = val.as_ref().unwrap();
+ match *inner {
+ UnionB::b(inner_val) => assert_eq!(inner_val, 10),
+ _ => panic!("Incorrect inner union variant! Tag found: {}", inner.get_tag()),
+ }
+ },
+ _ => panic!("Incorrect union variant! Tag found: {}", payload.param0.get_tag()),
+ }
+ }
+ }
+ }
+ conformance_mthd14_good_null_array_in_union {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 14);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod14Request => {
+ |payload: &ConformanceTestInterfaceMethod14Request| {
+ match payload.param0 {
+ UnionA::d(ref val) => assert_eq!(*val, None),
+ _ => panic!("Incorrect union variant! Tag found: {}", payload.param0.get_tag()),
+ }
+ }
+ }
+ }
+ conformance_mthd14_good_null_map_in_union {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 14);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod14Request => {
+ |payload: &ConformanceTestInterfaceMethod14Request| {
+ match payload.param0 {
+ UnionA::e(ref val) => assert_eq!(*val, None),
+ _ => panic!("Incorrect union variant! Tag found: {}", payload.param0.get_tag()),
+ }
+ }
+ }
+ }
+ conformance_mthd14_good_struct_in_union {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 14);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod14Request => {
+ |payload: &ConformanceTestInterfaceMethod14Request| {
+ match payload.param0 {
+ UnionA::c(ref val) => {
+ let struct_val = val.as_ref().unwrap();
+ assert_eq!(struct_val.i, 20);
+ },
+ _ => panic!("Incorrect union variant! Tag found: {}", payload.param0.get_tag()),
+ }
+ }
+ }
+ }
+ conformance_mthd14_good_unknown_union_tag {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 14);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod14Request => {
+ |payload: &ConformanceTestInterfaceMethod14Request| {
+ match payload.param0 {
+ UnionA::_Unknown(ref val) => assert_eq!(*val, 54),
+ _ => panic!("Incorrect union variant! Tag found: {}", payload.param0.get_tag()),
+ }
+ }
+ }
+ }
+ conformance_mthd15_good_union_in_array {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 15);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod15Request => {
+ |payload: &ConformanceTestInterfaceMethod15Request| {
+ assert_eq!(payload.param0.a, true);
+ assert_eq!(payload.param0.b, 22);
+ assert!(payload.param0.c.is_none());
+ assert!(payload.param0.d.is_some());
+ assert!(payload.param0.e.is_none());
+ let array = payload.param0.d.as_ref().unwrap();
+ assert_eq!(array.len(), 3);
+ for u in array.iter() {
+ match *u {
+ UnionA::b(ref val) => assert_eq!(*val, 10),
+ _ => panic!("Incorrect union variant! Tag found: {}", u.get_tag()),
+ }
+ }
+ }
+ }
+ }
+ conformance_mthd15_good_union_in_map {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 15);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod15Request => {
+ |payload: &ConformanceTestInterfaceMethod15Request| {
+ assert_eq!(payload.param0.a, true);
+ assert_eq!(payload.param0.b, 22);
+ assert!(payload.param0.c.is_none());
+ assert!(payload.param0.d.is_none());
+ assert!(payload.param0.e.is_some());
+ let map = payload.param0.e.as_ref().unwrap();
+ assert_eq!(map.len(), 3);
+ let mut expect_keys = HashMap::with_capacity(3);
+ expect_keys.insert(8, false);
+ expect_keys.insert(7, false);
+ expect_keys.insert(1, false);
+ for (key, value) in map.iter() {
+ expect_keys.insert(*key, true);
+ match *value {
+ UnionA::b(ref val) => assert_eq!(*val, 10),
+ _ => panic!("Incorrect union variant! Tag found: {}", value.get_tag()),
+ }
+ }
+ for (key, value) in expect_keys.iter() {
+ if *value == false {
+ panic!("Expected key `{}`, but not found!", *key);
+ }
+ }
+ }
+ }
+ }
+ conformance_mthd15_good_union_in_struct {
+ MessageHeader => {
+ |header: MessageHeader| {
+ assert_eq!(header.version, 0);
+ assert_eq!(header.name, 15);
+ assert_eq!(header.flags, 0);
+ }
+ },
+ ConformanceTestInterfaceMethod15Request => {
+ |payload: &ConformanceTestInterfaceMethod15Request| {
+ assert_eq!(payload.param0.a, true);
+ assert_eq!(payload.param0.b, 22);
+ assert!(payload.param0.c.is_some());
+ assert!(payload.param0.d.is_none());
+ 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()),
+ }
+ }
+ }
+ }
+}
« no previous file with comments | « mojo/public/rust/build.rs ('k') | mojo/public/rust/tests/util/mod.rs » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698