tools/fidl/gidl/goldens/rust_golden.rs.golden

#![cfg(test)]
#![allow(unused_imports)]

use {
    assert_matches::assert_matches,
    fidl::{AsHandleRef, Error, Handle, HandleDisposition, HandleInfo, HandleOp, ObjectType, Rights},
    fidl::encoding::{Context, Decode, Decoder, Encoder, WireFormatVersion},
    fidl_test_conformance as test_conformance,
    fuchsia_zircon_status::Status,
    fuchsia_zircon_types as zx_types,
    gidl_util::{
        HandleDef, HandleSubtype, copy_handle, create_handles, decode_value,
        get_handle_koid, get_info_handle_valid, repeat, select_handle_infos,
        select_raw_handle_infos, to_zx_handle_t, to_zx_handle_disposition_t,
    },
};

const _V2_CONTEXT: Context = Context { wire_format_version: WireFormatVersion::V2 };


#[test]
fn test_golden_bool_struct_v2_encode() {
    let value = test_conformance::GoldenBoolStruct { v: true };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenBoolStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_int_struct_v2_encode() {
    let value = test_conformance::GoldenIntStruct { v: 1i16 };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenIntStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_uint_struct_v2_encode() {
    let value = test_conformance::GoldenUintStruct { v: 1u16 };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenUintStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_float_struct_v2_encode() {
    let value = test_conformance::GoldenFloatStruct { v: 0f32 };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenFloatStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_double_struct_v2_encode() {
    let value = test_conformance::GoldenDoubleStruct { v: 0f64 };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenDoubleStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_string_struct_v2_encode() {
    let value = test_conformance::GoldenStringStruct { v: String::from("abcd") };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenStringStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0x61,0x62,0x63,0x64,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_nullable_string_struct_non_null_v2_encode() {
    let value = test_conformance::GoldenNullableStringStruct { v: Some(String::from("abcd")) };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenNullableStringStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0x61,0x62,0x63,0x64,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_nullable_string_struct_null_v2_encode() {
    let value = test_conformance::GoldenNullableStringStruct { v: None };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenNullableStringStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_enum_struct_v2_encode() {
    let value = test_conformance::GoldenEnumStruct { v: test_conformance::GoldenEnum::from_primitive(1u16).unwrap() };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenEnumStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_bits_struct_v2_encode() {
    let value = test_conformance::GoldenBitsStruct { v: test_conformance::GoldenBits::from_bits_retain(1u16) };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenBitsStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_table_struct_v2_encode() {
    let value = test_conformance::GoldenTableStruct { v: test_conformance::GoldenTable { v: Some(1i16), ..Default::default() } };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenTableStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0x01,0x00,0x00,0x00,0x00,0x00,0x01,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_union_struct_v2_encode() {
    let value = test_conformance::GoldenUnionStruct { v: test_conformance::GoldenUnion::V(1i16) };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenUnionStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x01,0x00,0x00,0x00,0x00,0x00,0x01,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_nullable_union_struct_non_null_v2_encode() {
    let value = test_conformance::GoldenNullableUnionStruct { v: Some(Box::new(test_conformance::GoldenUnion::V(1i16))) };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenNullableUnionStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x01,0x00,0x00,0x00,0x00,0x00,0x01,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_nullable_union_struct_null_v2_encode() {
    let value = test_conformance::GoldenNullableUnionStruct { v: None };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenNullableUnionStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_byte_array_struct_v2_encode() {
    let value = test_conformance::GoldenByteArrayStruct { v: [1u8, 2u8, 3u8, 4u8] };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenByteArrayStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x01,0x02,0x03,0x04,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_struct_array_struct_v2_encode() {
    let value = test_conformance::GoldenStructArrayStruct { v: [test_conformance::GoldenIntStruct { v: 1i16 }, test_conformance::GoldenIntStruct { v: 2i16 }] };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenStructArrayStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x01,0x00,0x02,0x00,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_byte_vector_struct_v2_encode() {
    let value = test_conformance::GoldenByteVectorStruct { v: vec![1u8, 2u8, 3u8, 4u8, 1u8, 2u8, 3u8, 4u8, 1u8, 2u8, 3u8, 4u8] };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenByteVectorStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x0c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0x01,0x02,0x03,0x04,0x01,0x02,0x03,0x04,
0x01,0x02,0x03,0x04,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_byte_nullable_vector_struct_non_null_v2_encode() {
    let value = test_conformance::GoldenNullableByteVectorStruct { v: Some(vec![1u8, 2u8, 3u8, 4u8]) };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenNullableByteVectorStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0x01,0x02,0x03,0x04,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_nullable_byte_vector_struct_null_v2_encode() {
    let value = test_conformance::GoldenNullableByteVectorStruct { v: None };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenNullableByteVectorStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_struct_vector_struct_v2_encode() {
    let value = test_conformance::GoldenStructVectorStruct { v: vec![test_conformance::GoldenIntStruct { v: 1i16 }, test_conformance::GoldenIntStruct { v: 2i16 }] };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenStructVectorStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0x01,0x00,0x02,0x00,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_nullable_struct_non_null_v2_encode() {
    let value = test_conformance::GoldenNullableStruct { v: Some(Box::new(test_conformance::GoldenBoolStruct { v: true })) };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenNullableStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_nullable_struct_null_v2_encode() {
    let value = test_conformance::GoldenNullableStruct { v: None };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenNullableStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, & value).unwrap();
    assert_eq!(bytes, &[
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_handle_basic_rights_struct_v2_encode() {
    let handle_defs = create_handles(&[
// #0
HandleDef{
	subtype: HandleSubtype::Channel,
	rights: Rights::from_bits(61454).unwrap(),
},
]);
    let mut value = test_conformance::GoldenHandleBasicRightsStruct { v: copy_handle(&handle_defs[0]) };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenHandleBasicRightsStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, &mut  value).unwrap();
    assert_eq!(bytes, &[
0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,
]);
    assert_eq!(
        handle_dispositions.iter().map(to_zx_handle_disposition_t).collect::<Vec<_>>(),
        &[
zx_types::zx_handle_disposition_t {
   operation: zx_types::ZX_HANDLE_OP_MOVE,
   handle: handle_defs[0].handle,
   type_: 5,
   rights: 49155,
   result: zx_types::ZX_OK,
},]
    );
}

#[test]
fn test_golden_nullable_handle_struct_non_null_v2_encode() {
    let handle_defs = create_handles(&[
// #0
HandleDef{
	subtype: HandleSubtype::Event,
	rights: Rights::from_bits(2147483648).unwrap(),
},
]);
    let mut value = test_conformance::GoldenNullableHandleStruct { v: Some(copy_handle(&handle_defs[0])) };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenNullableHandleStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, &mut  value).unwrap();
    assert_eq!(bytes, &[
0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,
]);
    assert_eq!(
        handle_dispositions.iter().map(to_zx_handle_t).collect::<Vec<_>>(),
        &[handle_defs[0].handle,
]
    );
}

#[test]
fn test_golden_nullable_handle_struct_null_v2_encode() {
    let mut value = test_conformance::GoldenNullableHandleStruct { v: None };
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenNullableHandleStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, &mut  value).unwrap();
    assert_eq!(bytes, &[
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
]);
    assert_eq!(handle_dispositions, &[]);
}

#[test]
fn test_golden_handle_basic_rights_struct_re_encode_v2_encode() {
    let handle_defs = create_handles(&[
// #0
HandleDef{
	subtype: HandleSubtype::Event,
	rights: Rights::from_bits(49155).unwrap(),
},
]);
    let mut value = decode_value::<test_conformance::GoldenHandleBasicRightsStruct>(_V2_CONTEXT, &[
0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,
], &mut select_handle_infos(&handle_defs, &[
0,]));
    let mut bytes = Vec::new();
    let mut handle_dispositions = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    Encoder::encode_with_context::<test_conformance::GoldenHandleBasicRightsStruct>(
        _V2_CONTEXT, &mut bytes, &mut handle_dispositions, &mut  value).unwrap();
    assert_eq!(bytes, &[
0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,
]);
    assert_eq!(
        handle_dispositions.iter().map(to_zx_handle_disposition_t).collect::<Vec<_>>(),
        &[
zx_types::zx_handle_disposition_t {
   operation: zx_types::ZX_HANDLE_OP_MOVE,
   handle: handle_defs[0].handle,
   type_: 5,
   rights: 49155,
   result: zx_types::ZX_OK,
},]
    );
}



#[test]
fn test_golden_bool_struct_v2_decode() {
    let bytes = &[
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenBoolStruct);
    Decoder::decode_with_context::<test_conformance::GoldenBoolStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenBoolStruct { v: true });

}

#[test]
fn test_golden_int_struct_v2_decode() {
    let bytes = &[
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenIntStruct);
    Decoder::decode_with_context::<test_conformance::GoldenIntStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenIntStruct { v: 1i16 });

}

#[test]
fn test_golden_uint_struct_v2_decode() {
    let bytes = &[
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenUintStruct);
    Decoder::decode_with_context::<test_conformance::GoldenUintStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenUintStruct { v: 1u16 });

}

#[test]
fn test_golden_float_struct_v2_decode() {
    let bytes = &[
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenFloatStruct);
    Decoder::decode_with_context::<test_conformance::GoldenFloatStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenFloatStruct { v: 0f32 });

}

#[test]
fn test_golden_double_struct_v2_decode() {
    let bytes = &[
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenDoubleStruct);
    Decoder::decode_with_context::<test_conformance::GoldenDoubleStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenDoubleStruct { v: 0f64 });

}

#[test]
fn test_golden_string_struct_v2_decode() {
    let bytes = &[
0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0x61,0x62,0x63,0x64,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenStringStruct);
    Decoder::decode_with_context::<test_conformance::GoldenStringStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenStringStruct { v: String::from("abcd") });

}

#[test]
fn test_golden_nullable_string_struct_non_null_v2_decode() {
    let bytes = &[
0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0x61,0x62,0x63,0x64,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenNullableStringStruct);
    Decoder::decode_with_context::<test_conformance::GoldenNullableStringStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenNullableStringStruct { v: Some(String::from("abcd")) });

}

#[test]
fn test_golden_nullable_string_struct_null_v2_decode() {
    let bytes = &[
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenNullableStringStruct);
    Decoder::decode_with_context::<test_conformance::GoldenNullableStringStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenNullableStringStruct { v: None });

}

#[test]
fn test_golden_enum_struct_v2_decode() {
    let bytes = &[
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenEnumStruct);
    Decoder::decode_with_context::<test_conformance::GoldenEnumStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenEnumStruct { v: test_conformance::GoldenEnum::from_primitive(1u16).unwrap() });

}

#[test]
fn test_golden_bits_struct_v2_decode() {
    let bytes = &[
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenBitsStruct);
    Decoder::decode_with_context::<test_conformance::GoldenBitsStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenBitsStruct { v: test_conformance::GoldenBits::from_bits_retain(1u16) });

}

#[test]
fn test_golden_table_struct_v2_decode() {
    let bytes = &[
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0x01,0x00,0x00,0x00,0x00,0x00,0x01,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenTableStruct);
    Decoder::decode_with_context::<test_conformance::GoldenTableStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenTableStruct { v: test_conformance::GoldenTable { v: Some(1i16), ..Default::default() } });

}

#[test]
fn test_golden_union_struct_v2_decode() {
    let bytes = &[
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x01,0x00,0x00,0x00,0x00,0x00,0x01,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenUnionStruct);
    Decoder::decode_with_context::<test_conformance::GoldenUnionStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenUnionStruct { v: test_conformance::GoldenUnion::V(1i16) });

}

#[test]
fn test_golden_nullable_union_struct_non_null_v2_decode() {
    let bytes = &[
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x01,0x00,0x00,0x00,0x00,0x00,0x01,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenNullableUnionStruct);
    Decoder::decode_with_context::<test_conformance::GoldenNullableUnionStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenNullableUnionStruct { v: Some(Box::new(test_conformance::GoldenUnion::V(1i16))) });

}

#[test]
fn test_golden_nullable_union_struct_null_v2_decode() {
    let bytes = &[
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenNullableUnionStruct);
    Decoder::decode_with_context::<test_conformance::GoldenNullableUnionStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenNullableUnionStruct { v: None });

}

#[test]
fn test_golden_byte_array_struct_v2_decode() {
    let bytes = &[
0x01,0x02,0x03,0x04,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenByteArrayStruct);
    Decoder::decode_with_context::<test_conformance::GoldenByteArrayStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenByteArrayStruct { v: [1u8, 2u8, 3u8, 4u8] });

}

#[test]
fn test_golden_struct_array_struct_v2_decode() {
    let bytes = &[
0x01,0x00,0x02,0x00,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenStructArrayStruct);
    Decoder::decode_with_context::<test_conformance::GoldenStructArrayStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenStructArrayStruct { v: [test_conformance::GoldenIntStruct { v: 1i16 }, test_conformance::GoldenIntStruct { v: 2i16 }] });

}

#[test]
fn test_golden_byte_vector_struct_v2_decode() {
    let bytes = &[
0x0c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0x01,0x02,0x03,0x04,0x01,0x02,0x03,0x04,
0x01,0x02,0x03,0x04,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenByteVectorStruct);
    Decoder::decode_with_context::<test_conformance::GoldenByteVectorStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenByteVectorStruct { v: vec![1u8, 2u8, 3u8, 4u8, 1u8, 2u8, 3u8, 4u8, 1u8, 2u8, 3u8, 4u8] });

}

#[test]
fn test_golden_byte_nullable_vector_struct_non_null_v2_decode() {
    let bytes = &[
0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0x01,0x02,0x03,0x04,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenNullableByteVectorStruct);
    Decoder::decode_with_context::<test_conformance::GoldenNullableByteVectorStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenNullableByteVectorStruct { v: Some(vec![1u8, 2u8, 3u8, 4u8]) });

}

#[test]
fn test_golden_nullable_byte_vector_struct_null_v2_decode() {
    let bytes = &[
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenNullableByteVectorStruct);
    Decoder::decode_with_context::<test_conformance::GoldenNullableByteVectorStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenNullableByteVectorStruct { v: None });

}

#[test]
fn test_golden_struct_vector_struct_v2_decode() {
    let bytes = &[
0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0x01,0x00,0x02,0x00,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenStructVectorStruct);
    Decoder::decode_with_context::<test_conformance::GoldenStructVectorStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenStructVectorStruct { v: vec![test_conformance::GoldenIntStruct { v: 1i16 }, test_conformance::GoldenIntStruct { v: 2i16 }] });

}

#[test]
fn test_golden_nullable_struct_non_null_v2_decode() {
    let bytes = &[
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenNullableStruct);
    Decoder::decode_with_context::<test_conformance::GoldenNullableStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenNullableStruct { v: Some(Box::new(test_conformance::GoldenBoolStruct { v: true })) });

}

#[test]
fn test_golden_nullable_struct_null_v2_decode() {
    let bytes = &[
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenNullableStruct);
    Decoder::decode_with_context::<test_conformance::GoldenNullableStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenNullableStruct { v: None });

}

#[test]
fn test_golden_handle_basic_rights_struct_v2_decode() {
    let bytes = &[
0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,
];
    let handle_defs = create_handles(&[
// #0
HandleDef{
	subtype: HandleSubtype::Event,
	rights: Rights::from_bits(53251).unwrap(),
},
]);
    let _handle_koids = handle_defs.iter().map(get_handle_koid).collect::<Vec<_>>();
    let mut handle_infos = select_handle_infos(&handle_defs, &[
0,]);
    let mut value = fidl::new_empty!(test_conformance::GoldenHandleBasicRightsStruct);
    Decoder::decode_with_context::<test_conformance::GoldenHandleBasicRightsStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    
match value.v.basic_info() {
	Ok(info) => {
		assert_eq!(info.koid.raw_koid(), _handle_koids[0]);
		assert_eq!(info.object_type, fidl::ObjectType::EVENT);
		assert_eq!(info.rights, Rights::from_bits(49155).unwrap());
	},
	Err(e) => panic!("handle basic_info failed: {}", e),
}


}

#[test]
fn test_golden_nullable_handle_struct_non_null_v2_decode() {
    let bytes = &[
0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,
];
    let handle_defs = create_handles(&[
// #0
HandleDef{
	subtype: HandleSubtype::Event,
	rights: Rights::from_bits(2147483648).unwrap(),
},
]);
    let _handle_koids = handle_defs.iter().map(get_handle_koid).collect::<Vec<_>>();
    let mut handle_infos = select_handle_infos(&handle_defs, &[
0,]);
    let mut value = fidl::new_empty!(test_conformance::GoldenNullableHandleStruct);
    Decoder::decode_with_context::<test_conformance::GoldenNullableHandleStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value.v.as_ref().unwrap().basic_info().unwrap().koid.raw_koid(), _handle_koids[0]);

}

#[test]
fn test_golden_nullable_handle_struct_null_v2_decode() {
    let bytes = &[
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenNullableHandleStruct);
    Decoder::decode_with_context::<test_conformance::GoldenNullableHandleStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenNullableHandleStruct { v: None });

}

#[test]
fn test_golden_table_unknown_dropped_v2_decode() {
    let bytes = &[
0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0xff,0xff,0xff,0x01,0x00,0x01,0x00,
];
    let handle_defs = create_handles(&[
// #0
HandleDef{
	subtype: HandleSubtype::Event,
	rights: Rights::from_bits(2147483648).unwrap(),
},
]);
    let _handle_koids = handle_defs.iter().map(get_handle_koid).collect::<Vec<_>>();
    let mut handle_infos = select_handle_infos(&handle_defs, &[
0,]);
    let mut value = fidl::new_empty!(test_conformance::GoldenTableStruct);
    Decoder::decode_with_context::<test_conformance::GoldenTableStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value).unwrap();
    assert_eq!(value, test_conformance::GoldenTableStruct { v: test_conformance::GoldenTable { ..Default::default() } });

    let unused_handles = select_raw_handle_infos(&handle_defs, &[
0,]);
    assert_eq!(
        unused_handles.iter().map(get_info_handle_valid).collect::<Vec<_>>(),
        repeat(Err(Status::BAD_HANDLE), unused_handles.len()),
    );
}



#[test]
fn test_golden_string_with_max_size2_v2_encode_failure() {
    let value = test_conformance::GoldenStringWithMaxSize2 { s: String::from("abc") };
    let mut bytes = Vec::new();
    let mut handles = Vec::new();
    bytes.resize(65536, 0xcd); // fill with junk data
    match Encoder::encode_with_context::<test_conformance::GoldenStringWithMaxSize2>(
        _V2_CONTEXT, &mut bytes, &mut handles, &value
    ) {
        Err(err) => assert_matches!(err, Error::StringTooLong { .. }),
        Ok(_) => panic!("unexpected successful encoding"),
    }
}



#[test]
fn test_golden_string_struct_null_body_v2_decode_failure() {
    let bytes = &[
0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
];
    let mut handle_infos = Vec::new();
    let mut value = fidl::new_empty!(test_conformance::GoldenStringStruct);
    match Decoder::decode_with_context::<test_conformance::GoldenStringStruct>(_V2_CONTEXT, bytes, &mut handle_infos, &mut value) {
        Err(err) => assert_matches!(err, Error::UnexpectedNullRef { .. }),
        Ok(_) => panic!("unexpected successful decoding"),
    }
}