2 files changed, 90 insertions, 0 deletions
diff --git a/src/test/run-pass/align-struct.rs b/src/test/run-pass/align-struct.rs
index 59d05399167..e42aa868c47 100644
--- a/src/test/run-pass/align-struct.rs
+++ b/src/test/run-pass/align-struct.rs
@@ -15,6 +15,7 @@ use std::mem;
 
 // Raising alignment
 #[repr(align(16))]
+#[derive(Clone, Copy, Debug)]
 struct Align16(i32);
 
 // Lowering has no effect
@@ -68,6 +69,11 @@ struct AlignLarge {
     stuff: [u8; 0x10000],
 }
 
+union UnionContainsAlign {
+    a: Align16,
+    b: f32
+}
+
 impl Align16 {
     // return aligned type
     pub fn new(i: i32) -> Align16 {
@@ -176,6 +182,18 @@ pub fn main() {
     }
     assert!(is_aligned_to(&e, 16));
 
+    // check union alignment
+    assert_eq!(mem::align_of::<UnionContainsAlign>(), 16);
+    assert_eq!(mem::size_of::<UnionContainsAlign>(), 16);
+    let u = UnionContainsAlign { a: Align16(10) };
+    unsafe {
+        assert_eq!(mem::align_of_val(&u.a), 16);
+        assert_eq!(mem::size_of_val(&u.a), 16);
+        assert_eq!(u.a.0, 10);
+        let UnionContainsAlign { a } = u;
+        assert_eq!(a.0, 10);
+    }
+
     // arrays of aligned elements should also be aligned
     assert_eq!(mem::align_of::<[Align16;2]>(), 16);
     assert_eq!(mem::size_of::<[Align16;2]>(), 32);
diff --git a/src/test/run-pass/union/union-align.rs b/src/test/run-pass/union/union-align.rs
new file mode 100644
index 00000000000..c0100df53e7
--- /dev/null
+++ b/src/test/run-pass/union/union-align.rs
@@ -0,0 +1,72 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(attr_literals)]
+#![feature(repr_align)]
+#![feature(untagged_unions)]
+
+use std::mem::{size_of, size_of_val, align_of, align_of_val};
+
+#[repr(align(16))]
+pub union U16 {
+    a: u8,
+    b: u32
+}
+
+fn main() {
+    assert_eq!(align_of::<U16>(), 16);
+    assert_eq!(size_of::<U16>(), 16);
+    let u = U16 { a: 10 };
+    unsafe {
+        assert_eq!(align_of_val(&u.a), 1);
+        assert_eq!(size_of_val(&u.a), 1);
+        assert_eq!(u.a, 10);
+    }
+
+    let u = U16 { b: 11 };
+    unsafe {
+        assert_eq!(align_of_val(&u.b), 4);
+        assert_eq!(size_of_val(&u.b), 4);
+        assert_eq!(u.b, 11);
+    }
+
+    hybrid::check_hybrid();
+}
+
+mod hybrid {
+    use std::mem::{size_of, align_of};
+
+    #[repr(align(16))]
+    struct S1 {
+        a: u16,
+        b: u8,
+    }
+
+    #[repr(align(32))]
+    union U {
+        s: S1,
+        c: u16,
+    }
+
+    #[repr(align(64))]
+    struct S2 {
+        d: u8,
+        u: U,
+    }
+
+    pub fn check_hybrid() {
+        assert_eq!(align_of::<S1>(), 16);
+        assert_eq!(size_of::<S1>(), 16);
+        assert_eq!(align_of::<U>(), 32);
+        assert_eq!(size_of::<U>(), 32);
+        assert_eq!(align_of::<S2>(), 64);
+        assert_eq!(size_of::<S2>(), 64);
+    }
+}