Rust: Add encoder/decoder tests

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.
+
+#[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()),
+                }
+            }
+        }
+    }
+}