2 // This test deserializes an enum in-place by transmuting to a union that
3 // should have the same layout, and manipulating the tag and payloads
4 // independently. This verifies that `repr(some_int)` has a stable representation,
5 // and that we don't miscompile these kinds of manipulations.
7 use std::time::Duration;
11 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
13 A(u32), // Single primitive value
14 B { x: u8, y: i16, z: u8 }, // Composite, and the offsets of `y` and `z`
15 // depend on tag being internal
17 D(Option<u32>), // Contains an enum
18 E(Duration), // Contains a struct
24 payload: MyEnumPayload,
28 #[allow(non_snake_case)]
36 #[repr(u8)] #[derive(Copy, Clone)] enum MyEnumTag { A, B, C, D, E }
37 #[repr(C)] #[derive(Copy, Clone)] struct MyEnumVariantA(u32);
38 #[repr(C)] #[derive(Copy, Clone)] struct MyEnumVariantB {x: u8, y: i16, z: u8 }
39 #[repr(C)] #[derive(Copy, Clone)] struct MyEnumVariantD(Option<u32>);
40 #[repr(C)] #[derive(Copy, Clone)] struct MyEnumVariantE(Duration);
43 let result: Vec<Result<MyEnum, ()>> = vec![
45 Ok(MyEnum::B { x: 206, y: 1145, z: 78 }),
48 Ok(MyEnum::D(Some(407))),
50 Ok(MyEnum::E(Duration::from_secs(100))),
54 // Binary serialized version of the above (little-endian)
55 let input: Vec<u8> = vec![
59 8, /* invalid tag value */
62 4, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
63 0, /* incomplete value */
66 let mut output = vec![];
67 let mut buf = &input[..];
70 // This should be safe, because we don't match on it unless it's fully formed,
71 // and it doesn't have a destructor.
73 // MyEnum is repr(C, u8) so it is guaranteed to have a separate discriminant and each
74 // variant can be zero initialized.
75 let mut dest: MyEnum = mem::zeroed();
77 match parse_my_enum(&mut dest, &mut buf) {
78 Ok(()) => output.push(Ok(dest)),
79 Err(()) => output.push(Err(())),
84 assert_eq!(output, result);
87 fn parse_my_enum<'a>(dest: &'a mut MyEnum, buf: &mut &[u8]) -> Result<(), ()> {
89 // Should be correct to do this transmute.
90 let dest: &'a mut MyEnumRepr = mem::transmute(dest);
91 let tag = read_u8(buf)?;
93 dest.tag = match tag {
104 dest.payload.A.0 = read_u32_le(buf)?;
107 dest.payload.B.x = read_u8(buf)?;
108 dest.payload.B.y = read_u16_le(buf)? as i16;
109 dest.payload.B.z = read_u8(buf)?;
115 let is_some = read_u8(buf)? == 0;
117 dest.payload.D.0 = Some(read_u32_le(buf)?);
119 dest.payload.D.0 = None;
123 let secs = read_u64_le(buf)?;
124 let nanos = read_u32_le(buf)?;
125 dest.payload.E.0 = Duration::new(secs, nanos);
136 fn read_u64_le(buf: &mut &[u8]) -> Result<u64, ()> {
137 if buf.len() < 8 { return Err(()) }
138 let val = (buf[0] as u64) << 0
139 | (buf[1] as u64) << 8
140 | (buf[2] as u64) << 16
141 | (buf[3] as u64) << 24
142 | (buf[4] as u64) << 32
143 | (buf[5] as u64) << 40
144 | (buf[6] as u64) << 48
145 | (buf[7] as u64) << 56;
150 fn read_u32_le(buf: &mut &[u8]) -> Result<u32, ()> {
151 if buf.len() < 4 { return Err(()) }
152 let val = (buf[0] as u32) << 0
153 | (buf[1] as u32) << 8
154 | (buf[2] as u32) << 16
155 | (buf[3] as u32) << 24;
160 fn read_u16_le(buf: &mut &[u8]) -> Result<u16, ()> {
161 if buf.len() < 2 { return Err(()) }
162 let val = (buf[0] as u16) << 0
163 | (buf[1] as u16) << 8;
168 fn read_u8(buf: &mut &[u8]) -> Result<u8, ()> {
169 if buf.len() < 1 { return Err(()) }