tests: Move run-pass tests without naming conflicts to ui

41 files changed, 565 insertions, 0 deletions

diff --git a/src/test/ui/unique/unique-assign-copy.rs b/src/test/ui/unique/unique-assign-copy.rs
new file mode 100644
index 00000000000..19469810237
--- /dev/null
+++ b/src/test/ui/unique/unique-assign-copy.rs
@@ -0,0 +1,13 @@
+// run-pass
+#![feature(box_syntax)]
+
+pub fn main() {
+    let mut i: Box<_> = box 1;
+    // Should be a copy
+    let mut j;
+    j = i.clone();
+    *i = 2;
+    *j = 3;
+    assert_eq!(*i, 2);
+    assert_eq!(*j, 3);
+}
diff --git a/src/test/ui/unique/unique-assign-drop.rs b/src/test/ui/unique/unique-assign-drop.rs
new file mode 100644
index 00000000000..32068e79df4
--- /dev/null
+++ b/src/test/ui/unique/unique-assign-drop.rs
@@ -0,0 +1,12 @@
+// run-pass
+#![allow(unused_assignments)]
+
+#![feature(box_syntax)]
+
+pub fn main() {
+    let i: Box<_> = box 1;
+    let mut j: Box<_> = box 2;
+    // Should drop the previous value of j
+    j = i;
+    assert_eq!(*j, 1);
+}
diff --git a/src/test/ui/unique/unique-assign-generic.rs b/src/test/ui/unique/unique-assign-generic.rs
new file mode 100644
index 00000000000..2d62ce59ad0
--- /dev/null
+++ b/src/test/ui/unique/unique-assign-generic.rs
@@ -0,0 +1,12 @@
+// run-pass
+#![feature(box_syntax)]
+
+fn f<T>(t: T) -> T {
+    let t1 = t;
+    t1
+}
+
+pub fn main() {
+    let t = f::<Box<_>>(box 100);
+    assert_eq!(t, box 100);
+}
diff --git a/src/test/ui/unique/unique-assign.rs b/src/test/ui/unique/unique-assign.rs
new file mode 100644
index 00000000000..5a88df071a0
--- /dev/null
+++ b/src/test/ui/unique/unique-assign.rs
@@ -0,0 +1,9 @@
+// run-pass
+#![allow(unused_mut)]
+#![feature(box_syntax)]
+
+pub fn main() {
+    let mut i: Box<_>;
+    i = box 1;
+    assert_eq!(*i, 1);
+}
diff --git a/src/test/ui/unique/unique-autoderef-field.rs b/src/test/ui/unique/unique-autoderef-field.rs
new file mode 100644
index 00000000000..0360646f133
--- /dev/null
+++ b/src/test/ui/unique/unique-autoderef-field.rs
@@ -0,0 +1,11 @@
+// run-pass
+#![feature(box_syntax)]
+
+struct J { j: isize }
+
+pub fn main() {
+    let i: Box<_> = box J {
+        j: 100
+    };
+    assert_eq!(i.j, 100);
+}
diff --git a/src/test/ui/unique/unique-autoderef-index.rs b/src/test/ui/unique/unique-autoderef-index.rs
new file mode 100644
index 00000000000..5a3d17a84ef
--- /dev/null
+++ b/src/test/ui/unique/unique-autoderef-index.rs
@@ -0,0 +1,7 @@
+// run-pass
+#![feature(box_syntax)]
+
+pub fn main() {
+    let i: Box<_> = box vec![100];
+    assert_eq!((*i)[0], 100);
+}
diff --git a/src/test/ui/unique/unique-cmp.rs b/src/test/ui/unique/unique-cmp.rs
new file mode 100644
index 00000000000..7bbc61d25ac
--- /dev/null
+++ b/src/test/ui/unique/unique-cmp.rs
@@ -0,0 +1,12 @@
+// run-pass
+#![allow(unused_allocation)]
+#![feature(box_syntax)]
+
+pub fn main() {
+    let i: Box<_> = box 100;
+    assert_eq!(i, box 100);
+    assert!(i < box 101);
+    assert!(i <= box 100);
+    assert!(i > box 99);
+    assert!(i >= box 99);
+}
diff --git a/src/test/ui/unique/unique-containing-tag.rs b/src/test/ui/unique/unique-containing-tag.rs
new file mode 100644
index 00000000000..f24b3a8645f
--- /dev/null
+++ b/src/test/ui/unique/unique-containing-tag.rs
@@ -0,0 +1,27 @@
+// run-pass
+#![allow(dead_code)]
+#![allow(non_camel_case_types)]
+
+// pretty-expanded FIXME #23616
+
+#![feature(box_syntax)]
+
+pub fn main() {
+    enum t { t1(isize), t2(isize), }
+
+    let _x: Box<_> = box t::t1(10);
+
+    /*alt *x {
+      t1(a) {
+        assert_eq!(a, 10);
+      }
+      _ { panic!(); }
+    }*/
+
+    /*alt x {
+      box t1(a) {
+        assert_eq!(a, 10);
+      }
+      _ { panic!(); }
+    }*/
+}
diff --git a/src/test/ui/unique/unique-create.rs b/src/test/ui/unique/unique-create.rs
new file mode 100644
index 00000000000..3df0f7d55fd
--- /dev/null
+++ b/src/test/ui/unique/unique-create.rs
@@ -0,0 +1,13 @@
+// run-pass
+#![allow(dead_code)]
+// pretty-expanded FIXME #23616
+
+#![feature(box_syntax)]
+
+pub fn main() {
+    let _: Box<_> = box 100;
+}
+
+fn vec() {
+    vec![0];
+}
diff --git a/src/test/ui/unique/unique-decl-init-copy.rs b/src/test/ui/unique/unique-decl-init-copy.rs
new file mode 100644
index 00000000000..6ae95949e84
--- /dev/null
+++ b/src/test/ui/unique/unique-decl-init-copy.rs
@@ -0,0 +1,12 @@
+// run-pass
+#![feature(box_syntax)]
+
+pub fn main() {
+    let mut i: Box<_> = box 1;
+    // Should be a copy
+    let mut j = i.clone();
+    *i = 2;
+    *j = 3;
+    assert_eq!(*i, 2);
+    assert_eq!(*j, 3);
+}
diff --git a/src/test/ui/unique/unique-decl-init.rs b/src/test/ui/unique/unique-decl-init.rs
new file mode 100644
index 00000000000..2c7b9d6054f
--- /dev/null
+++ b/src/test/ui/unique/unique-decl-init.rs
@@ -0,0 +1,8 @@
+// run-pass
+#![feature(box_syntax)]
+
+pub fn main() {
+    let i: Box<_> = box 1;
+    let j = i;
+    assert_eq!(*j, 1);
+}
diff --git a/src/test/ui/unique/unique-decl-move.rs b/src/test/ui/unique/unique-decl-move.rs
new file mode 100644
index 00000000000..4a5ee56ea92
--- /dev/null
+++ b/src/test/ui/unique/unique-decl-move.rs
@@ -0,0 +1,8 @@
+// run-pass
+#![feature(box_syntax)]
+
+pub fn main() {
+    let i: Box<_> = box 100;
+    let j = i;
+    assert_eq!(*j, 100);
+}
diff --git a/src/test/ui/unique/unique-decl.rs b/src/test/ui/unique/unique-decl.rs
new file mode 100644
index 00000000000..84a1b2a5b83
--- /dev/null
+++ b/src/test/ui/unique/unique-decl.rs
@@ -0,0 +1,11 @@
+// run-pass
+#![allow(dead_code)]
+
+
+pub fn main() {
+    let _: Box<isize>;
+}
+
+fn f(_i: Box<isize>) -> Box<isize> {
+    panic!();
+}
diff --git a/src/test/ui/unique/unique-deref.rs b/src/test/ui/unique/unique-deref.rs
new file mode 100644
index 00000000000..0c6af0f7f97
--- /dev/null
+++ b/src/test/ui/unique/unique-deref.rs
@@ -0,0 +1,7 @@
+// run-pass
+#![feature(box_syntax)]
+
+pub fn main() {
+    let i: Box<_> = box 100;
+    assert_eq!(*i, 100);
+}
diff --git a/src/test/ui/unique/unique-destructure.rs b/src/test/ui/unique/unique-destructure.rs
new file mode 100644
index 00000000000..9b9f95dfbca
--- /dev/null
+++ b/src/test/ui/unique/unique-destructure.rs
@@ -0,0 +1,10 @@
+// run-pass
+#![feature(box_patterns)]
+#![feature(box_syntax)]
+
+struct Foo { a: isize, b: isize }
+
+pub fn main() {
+    let box Foo{a, b} = box Foo{a: 100, b: 200};
+    assert_eq!(a + b, 300);
+}
diff --git a/src/test/ui/unique/unique-drop-complex.rs b/src/test/ui/unique/unique-drop-complex.rs
new file mode 100644
index 00000000000..0b7bda83b3f
--- /dev/null
+++ b/src/test/ui/unique/unique-drop-complex.rs
@@ -0,0 +1,8 @@
+// run-pass
+// pretty-expanded FIXME #23616
+
+#![feature(box_syntax)]
+
+pub fn main() {
+    let _x: Box<_> = box vec![0,0,0,0,0];
+}
diff --git a/src/test/ui/unique/unique-ffi-symbols.rs b/src/test/ui/unique/unique-ffi-symbols.rs
new file mode 100644
index 00000000000..b0fe22bc332
--- /dev/null
+++ b/src/test/ui/unique/unique-ffi-symbols.rs
@@ -0,0 +1,16 @@
+// run-pass
+// We used to have a __rust_abi shim that resulted in duplicated symbols
+// whenever the item path wasn't enough to disambiguate between them.
+fn main() {
+    let a = {
+        extern fn good() -> i32 { return 0; }
+        good as extern fn() -> i32
+    };
+    let b = {
+        extern fn good() -> i32 { return 5; }
+        good as extern fn() -> i32
+    };
+
+    assert!(a != b);
+    assert_eq!((a(), b()), (0, 5));
+}
diff --git a/src/test/ui/unique/unique-fn-arg-move.rs b/src/test/ui/unique/unique-fn-arg-move.rs
new file mode 100644
index 00000000000..ff33839e57e
--- /dev/null
+++ b/src/test/ui/unique/unique-fn-arg-move.rs
@@ -0,0 +1,11 @@
+// run-pass
+#![feature(box_syntax)]
+
+fn f(i: Box<isize>) {
+    assert_eq!(*i, 100);
+}
+
+pub fn main() {
+    let i = box 100;
+    f(i);
+}
diff --git a/src/test/ui/unique/unique-fn-arg-mut.rs b/src/test/ui/unique/unique-fn-arg-mut.rs
new file mode 100644
index 00000000000..e8bb35e4eb0
--- /dev/null
+++ b/src/test/ui/unique/unique-fn-arg-mut.rs
@@ -0,0 +1,12 @@
+// run-pass
+#![feature(box_syntax)]
+
+fn f(i: &mut Box<isize>) {
+    *i = box 200;
+}
+
+pub fn main() {
+    let mut i = box 100;
+    f(&mut i);
+    assert_eq!(*i, 200);
+}
diff --git a/src/test/ui/unique/unique-fn-arg.rs b/src/test/ui/unique/unique-fn-arg.rs
new file mode 100644
index 00000000000..75f2a767f59
--- /dev/null
+++ b/src/test/ui/unique/unique-fn-arg.rs
@@ -0,0 +1,12 @@
+// run-pass
+#![feature(box_syntax)]
+
+fn f(i: Box<isize>) {
+    assert_eq!(*i, 100);
+}
+
+pub fn main() {
+    f(box 100);
+    let i = box 100;
+    f(i);
+}
diff --git a/src/test/ui/unique/unique-fn-ret.rs b/src/test/ui/unique/unique-fn-ret.rs
new file mode 100644
index 00000000000..cd44cfa9836
--- /dev/null
+++ b/src/test/ui/unique/unique-fn-ret.rs
@@ -0,0 +1,10 @@
+// run-pass
+#![feature(box_syntax)]
+
+fn f() -> Box<isize> {
+    box 100
+}
+
+pub fn main() {
+    assert_eq!(f(), box 100);
+}
diff --git a/src/test/ui/unique/unique-generic-assign.rs b/src/test/ui/unique/unique-generic-assign.rs
new file mode 100644
index 00000000000..9c4405aa8ac
--- /dev/null
+++ b/src/test/ui/unique/unique-generic-assign.rs
@@ -0,0 +1,11 @@
+// run-pass
+#![allow(dead_code)]
+// Issue #976
+
+
+// pretty-expanded FIXME #23616
+
+fn f<T>(x: Box<T>) {
+    let _x2 = x;
+}
+pub fn main() { }
diff --git a/src/test/ui/unique/unique-in-tag.rs b/src/test/ui/unique/unique-in-tag.rs
new file mode 100644
index 00000000000..8d97ebe6590
--- /dev/null
+++ b/src/test/ui/unique/unique-in-tag.rs
@@ -0,0 +1,22 @@
+// run-pass
+#![allow(dead_code)]
+#![allow(non_camel_case_types)]
+
+#![feature(box_syntax)]
+
+fn test1() {
+    enum bar { u(Box<isize>), w(isize), }
+
+    let x = bar::u(box 10);
+    assert!(match x {
+      bar::u(a) => {
+        println!("{}", a);
+        *a
+      }
+      _ => { 66 }
+    } == 10);
+}
+
+pub fn main() {
+    test1();
+}
diff --git a/src/test/ui/unique/unique-in-vec-copy.rs b/src/test/ui/unique/unique-in-vec-copy.rs
new file mode 100644
index 00000000000..8907a8b20a7
--- /dev/null
+++ b/src/test/ui/unique/unique-in-vec-copy.rs
@@ -0,0 +1,16 @@
+// run-pass
+#![feature(box_syntax)]
+
+pub fn main() {
+    let mut a: Vec<Box<_>> = vec![box 10];
+    let b = a.clone();
+
+    assert_eq!(*a[0], 10);
+    assert_eq!(*b[0], 10);
+
+    // This should only modify the value in a, not b
+    *a[0] = 20;
+
+    assert_eq!(*a[0], 20);
+    assert_eq!(*b[0], 10);
+}
diff --git a/src/test/ui/unique/unique-in-vec.rs b/src/test/ui/unique/unique-in-vec.rs
new file mode 100644
index 00000000000..528ea4fb870
--- /dev/null
+++ b/src/test/ui/unique/unique-in-vec.rs
@@ -0,0 +1,7 @@
+// run-pass
+#![feature(box_syntax)]
+
+pub fn main() {
+    let vect : Vec<Box<_>> = vec![box 100];
+    assert_eq!(vect[0], box 100);
+}
diff --git a/src/test/ui/unique/unique-init.rs b/src/test/ui/unique/unique-init.rs
new file mode 100644
index 00000000000..c8a150522fd
--- /dev/null
+++ b/src/test/ui/unique/unique-init.rs
@@ -0,0 +1,8 @@
+// run-pass
+// pretty-expanded FIXME #23616
+
+#![feature(box_syntax)]
+
+pub fn main() {
+    let _i: Box<_> = box 100;
+}
diff --git a/src/test/ui/unique/unique-kinds.rs b/src/test/ui/unique/unique-kinds.rs
new file mode 100644
index 00000000000..f369a1e2a19
--- /dev/null
+++ b/src/test/ui/unique/unique-kinds.rs
@@ -0,0 +1,65 @@
+// run-pass
+#![feature(box_syntax)]
+
+use std::cmp::PartialEq;
+use std::fmt::Debug;
+
+fn sendable() {
+
+    fn f<T:Send + PartialEq + Debug>(i: T, j: T) {
+        assert_eq!(i, j);
+    }
+
+    fn g<T:Send + PartialEq>(i: T, j: T) {
+        assert!(i != j);
+    }
+
+    let i: Box<_> = box 100;
+    let j: Box<_> = box 100;
+    f(i, j);
+    let i: Box<_> = box 100;
+    let j: Box<_> = box 101;
+    g(i, j);
+}
+
+fn copyable() {
+
+    fn f<T:PartialEq + Debug>(i: T, j: T) {
+        assert_eq!(i, j);
+    }
+
+    fn g<T:PartialEq>(i: T, j: T) {
+        assert!(i != j);
+    }
+
+    let i: Box<_> = box 100;
+    let j: Box<_> = box 100;
+    f(i, j);
+    let i: Box<_> = box 100;
+    let j: Box<_> = box 101;
+    g(i, j);
+}
+
+fn noncopyable() {
+
+    fn f<T:PartialEq + Debug>(i: T, j: T) {
+        assert_eq!(i, j);
+    }
+
+    fn g<T:PartialEq>(i: T, j: T) {
+        assert!(i != j);
+    }
+
+    let i: Box<_> = box 100;
+    let j: Box<_> = box 100;
+    f(i, j);
+    let i: Box<_> = box 100;
+    let j: Box<_> = box 101;
+    g(i, j);
+}
+
+pub fn main() {
+    sendable();
+    copyable();
+    noncopyable();
+}
diff --git a/src/test/ui/unique/unique-log.rs b/src/test/ui/unique/unique-log.rs
new file mode 100644
index 00000000000..27977717706
--- /dev/null
+++ b/src/test/ui/unique/unique-log.rs
@@ -0,0 +1,7 @@
+// run-pass
+#![feature(box_syntax)]
+
+pub fn main() {
+    let i: Box<_> = box 100;
+    println!("{}", i);
+}
diff --git a/src/test/ui/unique/unique-match-discrim.rs b/src/test/ui/unique/unique-match-discrim.rs
new file mode 100644
index 00000000000..6e6d7432277
--- /dev/null
+++ b/src/test/ui/unique/unique-match-discrim.rs
@@ -0,0 +1,12 @@
+// run-pass
+#![allow(dead_code)]
+// Issue #961
+
+// pretty-expanded FIXME #23616
+
+fn altsimple() {
+    match Box::new(true) {
+      _ => { }
+    }
+}
+pub fn main() { }
diff --git a/src/test/ui/unique/unique-move-drop.rs b/src/test/ui/unique/unique-move-drop.rs
new file mode 100644
index 00000000000..e1ea58b39ef
--- /dev/null
+++ b/src/test/ui/unique/unique-move-drop.rs
@@ -0,0 +1,11 @@
+// run-pass
+
+#![allow(unused_variables)]
+#![feature(box_syntax)]
+
+pub fn main() {
+    let i: Box<_> = box 100;
+    let j: Box<_> = box 200;
+    let j = i;
+    assert_eq!(*j, 100);
+}
diff --git a/src/test/ui/unique/unique-move-temp.rs b/src/test/ui/unique/unique-move-temp.rs
new file mode 100644
index 00000000000..4f5de50b722
--- /dev/null
+++ b/src/test/ui/unique/unique-move-temp.rs
@@ -0,0 +1,9 @@
+// run-pass
+#![allow(unused_mut)]
+#![feature(box_syntax)]
+
+pub fn main() {
+    let mut i: Box<_>;
+    i = box 100;
+    assert_eq!(*i, 100);
+}
diff --git a/src/test/ui/unique/unique-move.rs b/src/test/ui/unique/unique-move.rs
new file mode 100644
index 00000000000..0f6bff1432b
--- /dev/null
+++ b/src/test/ui/unique/unique-move.rs
@@ -0,0 +1,10 @@
+// run-pass
+#![allow(unused_mut)]
+#![feature(box_syntax)]
+
+pub fn main() {
+    let i: Box<_> = box 100;
+    let mut j;
+    j = i;
+    assert_eq!(*j, 100);
+}
diff --git a/src/test/ui/unique/unique-mutable.rs b/src/test/ui/unique/unique-mutable.rs
new file mode 100644
index 00000000000..176cf33d488
--- /dev/null
+++ b/src/test/ui/unique/unique-mutable.rs
@@ -0,0 +1,8 @@
+// run-pass
+#![feature(box_syntax)]
+
+pub fn main() {
+    let mut i: Box<_> = box 0;
+    *i = 1;
+    assert_eq!(*i, 1);
+}
diff --git a/src/test/ui/unique/unique-object-move.rs b/src/test/ui/unique/unique-object-move.rs
new file mode 100644
index 00000000000..84e8cdb32b8
--- /dev/null
+++ b/src/test/ui/unique/unique-object-move.rs
@@ -0,0 +1,20 @@
+// run-pass
+#![allow(dead_code)]
+// Issue #5192
+
+// pretty-expanded FIXME #23616
+
+#![feature(box_syntax)]
+
+pub trait EventLoop { fn foo(&self) {} }
+
+pub struct UvEventLoop {
+    uvio: isize
+}
+
+impl EventLoop for UvEventLoop { }
+
+pub fn main() {
+    let loop_: Box<dyn EventLoop> = box UvEventLoop { uvio: 0 } as Box<dyn EventLoop>;
+    let _loop2_ = loop_;
+}
diff --git a/src/test/ui/unique/unique-pat-2.rs b/src/test/ui/unique/unique-pat-2.rs
new file mode 100644
index 00000000000..c18e029b252
--- /dev/null
+++ b/src/test/ui/unique/unique-pat-2.rs
@@ -0,0 +1,18 @@
+// run-pass
+#![allow(dead_code)]
+#![allow(non_camel_case_types)]
+#![allow(non_shorthand_field_patterns)]
+
+#![feature(box_patterns)]
+#![feature(box_syntax)]
+
+struct Foo {a: isize, b: usize}
+
+enum bar { u(Box<Foo>), w(isize), }
+
+pub fn main() {
+    assert!(match bar::u(box Foo{a: 10, b: 40}) {
+              bar::u(box Foo{a: a, b: b}) => { a + (b as isize) }
+              _ => { 66 }
+            } == 50);
+}
diff --git a/src/test/ui/unique/unique-pat-3.rs b/src/test/ui/unique/unique-pat-3.rs
new file mode 100644
index 00000000000..e17b5a3ddb4
--- /dev/null
+++ b/src/test/ui/unique/unique-pat-3.rs
@@ -0,0 +1,17 @@
+// run-pass
+#![allow(dead_code)]
+#![allow(non_camel_case_types)]
+
+#![feature(box_syntax)]
+
+enum bar { u(Box<isize>), w(isize), }
+
+pub fn main() {
+    assert!(match bar::u(box 10) {
+      bar::u(a) => {
+        println!("{}", a);
+        *a
+      }
+      _ => { 66 }
+    } == 10);
+}
diff --git a/src/test/ui/unique/unique-pat.rs b/src/test/ui/unique/unique-pat.rs
new file mode 100644
index 00000000000..b32195ac274
--- /dev/null
+++ b/src/test/ui/unique/unique-pat.rs
@@ -0,0 +1,15 @@
+// run-pass
+
+#![feature(box_patterns)]
+#![feature(box_syntax)]
+
+fn simple() {
+    match box true {
+      box true => { }
+      _ => { panic!(); }
+    }
+}
+
+pub fn main() {
+    simple();
+}
diff --git a/src/test/ui/unique/unique-rec.rs b/src/test/ui/unique/unique-rec.rs
new file mode 100644
index 00000000000..c8bddd246a8
--- /dev/null
+++ b/src/test/ui/unique/unique-rec.rs
@@ -0,0 +1,10 @@
+// run-pass
+#![feature(box_syntax)]
+
+struct X { x: isize }
+
+pub fn main() {
+    let x: Box<_> = box X {x: 1};
+    let bar = x;
+    assert_eq!(bar.x, 1);
+}
diff --git a/src/test/ui/unique/unique-send-2.rs b/src/test/ui/unique/unique-send-2.rs
new file mode 100644
index 00000000000..22f0e6c3a49
--- /dev/null
+++ b/src/test/ui/unique/unique-send-2.rs
@@ -0,0 +1,35 @@
+// run-pass
+#![allow(unused_must_use)]
+// ignore-emscripten no threads support
+
+#![feature(box_syntax)]
+
+use std::sync::mpsc::{channel, Sender};
+use std::thread;
+
+fn child(tx: &Sender<Box<usize>>, i: usize) {
+    tx.send(box i).unwrap();
+}
+
+pub fn main() {
+    let (tx, rx) = channel();
+    let n = 100;
+    let mut expected = 0;
+    let ts = (0..n).map(|i| {
+        expected += i;
+        let tx = tx.clone();
+        thread::spawn(move|| {
+            child(&tx, i)
+        })
+    }).collect::<Vec<_>>();
+
+    let mut actual = 0;
+    for _ in 0..n {
+        let j = rx.recv().unwrap();
+        actual += *j;
+    }
+
+    assert_eq!(expected, actual);
+
+    for t in ts { t.join(); }
+}
diff --git a/src/test/ui/unique/unique-send.rs b/src/test/ui/unique/unique-send.rs
new file mode 100644
index 00000000000..a5c7561b9ae
--- /dev/null
+++ b/src/test/ui/unique/unique-send.rs
@@ -0,0 +1,11 @@
+// run-pass
+#![feature(box_syntax)]
+
+use std::sync::mpsc::channel;
+
+pub fn main() {
+    let (tx, rx) = channel::<Box<_>>();
+    tx.send(box 100).unwrap();
+    let v = rx.recv().unwrap();
+    assert_eq!(v, box 100);
+}
diff --git a/src/test/ui/unique/unique-swap.rs b/src/test/ui/unique/unique-swap.rs
new file mode 100644
index 00000000000..33a6b3b3ed0
--- /dev/null
+++ b/src/test/ui/unique/unique-swap.rs
@@ -0,0 +1,12 @@
+// run-pass
+#![feature(box_syntax)]
+
+use std::mem::swap;
+
+pub fn main() {
+    let mut i: Box<_> = box 100;
+    let mut j: Box<_> = box 200;
+    swap(&mut i, &mut j);
+    assert_eq!(i, box 200);
+    assert_eq!(j, box 100);
+}