Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

6 files changed, 882 insertions, 0 deletions

diff --git a/third_party/rust/crossbeam-utils-0.6.6/tests/atomic_cell.rs b/third_party/rust/crossbeam-utils-0.6.6/tests/atomic_cell.rs
new file mode 100644
index 0000000000..9406192333
--- /dev/null
+++ b/third_party/rust/crossbeam-utils-0.6.6/tests/atomic_cell.rs
@@ -0,0 +1,225 @@
+extern crate crossbeam_utils;
+
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::SeqCst;
+
+use crossbeam_utils::atomic::AtomicCell;
+
+#[test]
+fn is_lock_free() {
+    struct UsizeWrap(usize);
+    struct U8Wrap(bool);
+
+    assert_eq!(AtomicCell::<usize>::is_lock_free(), true);
+    assert_eq!(AtomicCell::<isize>::is_lock_free(), true);
+    assert_eq!(AtomicCell::<UsizeWrap>::is_lock_free(), true);
+
+    assert_eq!(AtomicCell::<u8>::is_lock_free(), cfg!(feature = "nightly"));
+    assert_eq!(
+        AtomicCell::<bool>::is_lock_free(),
+        cfg!(feature = "nightly")
+    );
+    assert_eq!(
+        AtomicCell::<U8Wrap>::is_lock_free(),
+        cfg!(feature = "nightly")
+    );
+}
+
+#[test]
+fn drops_unit() {
+    static CNT: AtomicUsize = AtomicUsize::new(0);
+    CNT.store(0, SeqCst);
+
+    #[derive(Debug, PartialEq, Eq)]
+    struct Foo();
+
+    impl Foo {
+        fn new() -> Foo {
+            CNT.fetch_add(1, SeqCst);
+            Foo()
+        }
+    }
+
+    impl Drop for Foo {
+        fn drop(&mut self) {
+            CNT.fetch_sub(1, SeqCst);
+        }
+    }
+
+    impl Default for Foo {
+        fn default() -> Foo {
+            Foo::new()
+        }
+    }
+
+    let a = AtomicCell::new(Foo::new());
+
+    assert_eq!(a.swap(Foo::new()), Foo::new());
+    assert_eq!(CNT.load(SeqCst), 1);
+
+    a.store(Foo::new());
+    assert_eq!(CNT.load(SeqCst), 1);
+
+    assert_eq!(a.swap(Foo::default()), Foo::new());
+    assert_eq!(CNT.load(SeqCst), 1);
+
+    drop(a);
+    assert_eq!(CNT.load(SeqCst), 0);
+}
+
+#[test]
+fn drops_u8() {
+    static CNT: AtomicUsize = AtomicUsize::new(0);
+    CNT.store(0, SeqCst);
+
+    #[derive(Debug, PartialEq, Eq)]
+    struct Foo(u8);
+
+    impl Foo {
+        fn new(val: u8) -> Foo {
+            CNT.fetch_add(1, SeqCst);
+            Foo(val)
+        }
+    }
+
+    impl Drop for Foo {
+        fn drop(&mut self) {
+            CNT.fetch_sub(1, SeqCst);
+        }
+    }
+
+    impl Default for Foo {
+        fn default() -> Foo {
+            Foo::new(0)
+        }
+    }
+
+    let a = AtomicCell::new(Foo::new(5));
+
+    assert_eq!(a.swap(Foo::new(6)), Foo::new(5));
+    assert_eq!(a.swap(Foo::new(1)), Foo::new(6));
+    assert_eq!(CNT.load(SeqCst), 1);
+
+    a.store(Foo::new(2));
+    assert_eq!(CNT.load(SeqCst), 1);
+
+    assert_eq!(a.swap(Foo::default()), Foo::new(2));
+    assert_eq!(CNT.load(SeqCst), 1);
+
+    assert_eq!(a.swap(Foo::default()), Foo::new(0));
+    assert_eq!(CNT.load(SeqCst), 1);
+
+    drop(a);
+    assert_eq!(CNT.load(SeqCst), 0);
+}
+
+#[test]
+fn drops_usize() {
+    static CNT: AtomicUsize = AtomicUsize::new(0);
+    CNT.store(0, SeqCst);
+
+    #[derive(Debug, PartialEq, Eq)]
+    struct Foo(usize);
+
+    impl Foo {
+        fn new(val: usize) -> Foo {
+            CNT.fetch_add(1, SeqCst);
+            Foo(val)
+        }
+    }
+
+    impl Drop for Foo {
+        fn drop(&mut self) {
+            CNT.fetch_sub(1, SeqCst);
+        }
+    }
+
+    impl Default for Foo {
+        fn default() -> Foo {
+            Foo::new(0)
+        }
+    }
+
+    let a = AtomicCell::new(Foo::new(5));
+
+    assert_eq!(a.swap(Foo::new(6)), Foo::new(5));
+    assert_eq!(a.swap(Foo::new(1)), Foo::new(6));
+    assert_eq!(CNT.load(SeqCst), 1);
+
+    a.store(Foo::new(2));
+    assert_eq!(CNT.load(SeqCst), 1);
+
+    assert_eq!(a.swap(Foo::default()), Foo::new(2));
+    assert_eq!(CNT.load(SeqCst), 1);
+
+    assert_eq!(a.swap(Foo::default()), Foo::new(0));
+    assert_eq!(CNT.load(SeqCst), 1);
+
+    drop(a);
+    assert_eq!(CNT.load(SeqCst), 0);
+}
+
+#[test]
+fn modular_u8() {
+    #[derive(Clone, Copy, Eq, Debug, Default)]
+    struct Foo(u8);
+
+    impl PartialEq for Foo {
+        fn eq(&self, other: &Foo) -> bool {
+            self.0 % 5 == other.0 % 5
+        }
+    }
+
+    let a = AtomicCell::new(Foo(1));
+
+    assert_eq!(a.load(), Foo(1));
+    assert_eq!(a.swap(Foo(2)), Foo(11));
+    assert_eq!(a.load(), Foo(52));
+
+    a.store(Foo(0));
+    assert_eq!(a.compare_exchange(Foo(0), Foo(5)), Ok(Foo(100)));
+    assert_eq!(a.load().0, 5);
+    assert_eq!(a.compare_exchange(Foo(10), Foo(15)), Ok(Foo(100)));
+    assert_eq!(a.load().0, 15);
+}
+
+#[test]
+fn modular_usize() {
+    #[derive(Clone, Copy, Eq, Debug, Default)]
+    struct Foo(usize);
+
+    impl PartialEq for Foo {
+        fn eq(&self, other: &Foo) -> bool {
+            self.0 % 5 == other.0 % 5
+        }
+    }
+
+    let a = AtomicCell::new(Foo(1));
+
+    assert_eq!(a.load(), Foo(1));
+    assert_eq!(a.swap(Foo(2)), Foo(11));
+    assert_eq!(a.load(), Foo(52));
+
+    a.store(Foo(0));
+    assert_eq!(a.compare_exchange(Foo(0), Foo(5)), Ok(Foo(100)));
+    assert_eq!(a.load().0, 5);
+    assert_eq!(a.compare_exchange(Foo(10), Foo(15)), Ok(Foo(100)));
+    assert_eq!(a.load().0, 15);
+}
+
+#[test]
+fn garbage_padding() {
+    #[derive(Copy, Clone, Eq, PartialEq)]
+    struct Object {
+        a: i64,
+        b: i32,
+    }
+
+    let cell = AtomicCell::new(Object { a: 0, b: 0 });
+    let _garbage = [0xfe, 0xfe, 0xfe, 0xfe, 0xfe]; // Needed
+    let next = Object { a: 0, b: 0 };
+
+    let prev = cell.load();
+    assert!(cell.compare_exchange(prev, next).is_ok());
+    println!();
+}
diff --git a/third_party/rust/crossbeam-utils-0.6.6/tests/cache_padded.rs b/third_party/rust/crossbeam-utils-0.6.6/tests/cache_padded.rs
new file mode 100644
index 0000000000..8ad7d40a4e
--- /dev/null
+++ b/third_party/rust/crossbeam-utils-0.6.6/tests/cache_padded.rs
@@ -0,0 +1,112 @@
+extern crate crossbeam_utils;
+
+use std::cell::Cell;
+use std::mem;
+
+use crossbeam_utils::CachePadded;
+
+#[test]
+fn default() {
+    let x: CachePadded<u64> = Default::default();
+    assert_eq!(*x, 0);
+}
+
+#[test]
+fn store_u64() {
+    let x: CachePadded<u64> = CachePadded::new(17);
+    assert_eq!(*x, 17);
+}
+
+#[test]
+fn store_pair() {
+    let x: CachePadded<(u64, u64)> = CachePadded::new((17, 37));
+    assert_eq!(x.0, 17);
+    assert_eq!(x.1, 37);
+}
+
+#[test]
+fn distance() {
+    let arr = [CachePadded::new(17u8), CachePadded::new(37u8)];
+    let a = &*arr[0] as *const u8;
+    let b = &*arr[1] as *const u8;
+    assert!(unsafe { a.offset(64) } <= b);
+}
+
+#[test]
+fn different_sizes() {
+    CachePadded::new(17u8);
+    CachePadded::new(17u16);
+    CachePadded::new(17u32);
+    CachePadded::new([17u64; 0]);
+    CachePadded::new([17u64; 1]);
+    CachePadded::new([17u64; 2]);
+    CachePadded::new([17u64; 3]);
+    CachePadded::new([17u64; 4]);
+    CachePadded::new([17u64; 5]);
+    CachePadded::new([17u64; 6]);
+    CachePadded::new([17u64; 7]);
+    CachePadded::new([17u64; 8]);
+}
+
+#[test]
+fn large() {
+    let a = [17u64; 9];
+    let b = CachePadded::new(a);
+    assert!(mem::size_of_val(&a) <= mem::size_of_val(&b));
+}
+
+#[test]
+fn debug() {
+    assert_eq!(
+        format!("{:?}", CachePadded::new(17u64)),
+        "CachePadded { value: 17 }"
+    );
+}
+
+#[test]
+fn drops() {
+    let count = Cell::new(0);
+
+    struct Foo<'a>(&'a Cell<usize>);
+
+    impl<'a> Drop for Foo<'a> {
+        fn drop(&mut self) {
+            self.0.set(self.0.get() + 1);
+        }
+    }
+
+    let a = CachePadded::new(Foo(&count));
+    let b = CachePadded::new(Foo(&count));
+
+    assert_eq!(count.get(), 0);
+    drop(a);
+    assert_eq!(count.get(), 1);
+    drop(b);
+    assert_eq!(count.get(), 2);
+}
+
+#[test]
+fn clone() {
+    let a = CachePadded::new(17);
+    let b = a.clone();
+    assert_eq!(*a, *b);
+}
+
+#[test]
+fn runs_custom_clone() {
+    let count = Cell::new(0);
+
+    struct Foo<'a>(&'a Cell<usize>);
+
+    impl<'a> Clone for Foo<'a> {
+        fn clone(&self) -> Foo<'a> {
+            self.0.set(self.0.get() + 1);
+            Foo::<'a>(self.0)
+        }
+    }
+
+    let a = CachePadded::new(Foo(&count));
+    let _ = a.clone();
+
+    assert_eq!(count.get(), 1);
+}
diff --git a/third_party/rust/crossbeam-utils-0.6.6/tests/parker.rs b/third_party/rust/crossbeam-utils-0.6.6/tests/parker.rs
new file mode 100644
index 0000000000..3f4514626a
--- /dev/null
+++ b/third_party/rust/crossbeam-utils-0.6.6/tests/parker.rs
@@ -0,0 +1,43 @@
+extern crate crossbeam_utils;
+
+use std::thread::sleep;
+use std::time::Duration;
+use std::u32;
+
+use crossbeam_utils::sync::Parker;
+use crossbeam_utils::thread;
+
+#[test]
+fn park_timeout_unpark_before() {
+    let p = Parker::new();
+    for _ in 0..10 {
+        p.unparker().unpark();
+        p.park_timeout(Duration::from_millis(u32::MAX as u64));
+    }
+}
+
+#[test]
+fn park_timeout_unpark_not_called() {
+    let p = Parker::new();
+    for _ in 0..10 {
+        p.park_timeout(Duration::from_millis(10));
+    }
+}
+
+#[test]
+fn park_timeout_unpark_called_other_thread() {
+    for _ in 0..10 {
+        let p = Parker::new();
+        let u = p.unparker().clone();
+
+        thread::scope(|scope| {
+            scope.spawn(move |_| {
+                sleep(Duration::from_millis(50));
+                u.unpark();
+            });
+
+            p.park_timeout(Duration::from_millis(u32::MAX as u64));
+        })
+        .unwrap();
+    }
+}
diff --git a/third_party/rust/crossbeam-utils-0.6.6/tests/sharded_lock.rs b/third_party/rust/crossbeam-utils-0.6.6/tests/sharded_lock.rs
new file mode 100644
index 0000000000..c98de79998
--- /dev/null
+++ b/third_party/rust/crossbeam-utils-0.6.6/tests/sharded_lock.rs
@@ -0,0 +1,255 @@
+extern crate crossbeam_utils;
+extern crate rand;
+
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::mpsc::channel;
+use std::sync::{Arc, TryLockError};
+use std::thread;
+
+use crossbeam_utils::sync::ShardedLock;
+use rand::Rng;
+
+#[derive(Eq, PartialEq, Debug)]
+struct NonCopy(i32);
+
+#[test]
+fn smoke() {
+    let l = ShardedLock::new(());
+    drop(l.read().unwrap());
+    drop(l.write().unwrap());
+    drop((l.read().unwrap(), l.read().unwrap()));
+    drop(l.write().unwrap());
+}
+
+#[test]
+fn frob() {
+    const N: u32 = 10;
+    const M: usize = 1000;
+
+    let r = Arc::new(ShardedLock::new(()));
+
+    let (tx, rx) = channel::<()>();
+    for _ in 0..N {
+        let tx = tx.clone();
+        let r = r.clone();
+        thread::spawn(move || {
+            let mut rng = rand::thread_rng();
+            for _ in 0..M {
+                if rng.gen_bool(1.0 / (N as f64)) {
+                    drop(r.write().unwrap());
+                } else {
+                    drop(r.read().unwrap());
+                }
+            }
+            drop(tx);
+        });
+    }
+    drop(tx);
+    let _ = rx.recv();
+}
+
+#[test]
+fn arc_poison_wr() {
+    let arc = Arc::new(ShardedLock::new(1));
+    let arc2 = arc.clone();
+    let _: Result<(), _> = thread::spawn(move || {
+        let _lock = arc2.write().unwrap();
+        panic!();
+    })
+    .join();
+    assert!(arc.read().is_err());
+}
+
+#[test]
+fn arc_poison_ww() {
+    let arc = Arc::new(ShardedLock::new(1));
+    assert!(!arc.is_poisoned());
+    let arc2 = arc.clone();
+    let _: Result<(), _> = thread::spawn(move || {
+        let _lock = arc2.write().unwrap();
+        panic!();
+    })
+    .join();
+    assert!(arc.write().is_err());
+    assert!(arc.is_poisoned());
+}
+
+#[test]
+fn arc_no_poison_rr() {
+    let arc = Arc::new(ShardedLock::new(1));
+    let arc2 = arc.clone();
+    let _: Result<(), _> = thread::spawn(move || {
+        let _lock = arc2.read().unwrap();
+        panic!();
+    })
+    .join();
+    let lock = arc.read().unwrap();
+    assert_eq!(*lock, 1);
+}
+#[test]
+fn arc_no_poison_sl() {
+    let arc = Arc::new(ShardedLock::new(1));
+    let arc2 = arc.clone();
+    let _: Result<(), _> = thread::spawn(move || {
+        let _lock = arc2.read().unwrap();
+        panic!()
+    })
+    .join();
+    let lock = arc.write().unwrap();
+    assert_eq!(*lock, 1);
+}
+
+#[test]
+fn arc() {
+    let arc = Arc::new(ShardedLock::new(0));
+    let arc2 = arc.clone();
+    let (tx, rx) = channel();
+
+    thread::spawn(move || {
+        let mut lock = arc2.write().unwrap();
+        for _ in 0..10 {
+            let tmp = *lock;
+            *lock = -1;
+            thread::yield_now();
+            *lock = tmp + 1;
+        }
+        tx.send(()).unwrap();
+    });
+
+    // Readers try to catch the writer in the act
+    let mut children = Vec::new();
+    for _ in 0..5 {
+        let arc3 = arc.clone();
+        children.push(thread::spawn(move || {
+            let lock = arc3.read().unwrap();
+            assert!(*lock >= 0);
+        }));
+    }
+
+    // Wait for children to pass their asserts
+    for r in children {
+        assert!(r.join().is_ok());
+    }
+
+    // Wait for writer to finish
+    rx.recv().unwrap();
+    let lock = arc.read().unwrap();
+    assert_eq!(*lock, 10);
+}
+
+#[test]
+fn arc_access_in_unwind() {
+    let arc = Arc::new(ShardedLock::new(1));
+    let arc2 = arc.clone();
+    let _ = thread::spawn(move || -> () {
+        struct Unwinder {
+            i: Arc<ShardedLock<isize>>,
+        }
+        impl Drop for Unwinder {
+            fn drop(&mut self) {
+                let mut lock = self.i.write().unwrap();
+                *lock += 1;
+            }
+        }
+        let _u = Unwinder { i: arc2 };
+        panic!();
+    })
+    .join();
+    let lock = arc.read().unwrap();
+    assert_eq!(*lock, 2);
+}
+
+#[test]
+fn unsized_type() {
+    let sl: &ShardedLock<[i32]> = &ShardedLock::new([1, 2, 3]);
+    {
+        let b = &mut *sl.write().unwrap();
+        b[0] = 4;
+        b[2] = 5;
+    }
+    let comp: &[i32] = &[4, 2, 5];
+    assert_eq!(&*sl.read().unwrap(), comp);
+}
+
+#[test]
+fn try_write() {
+    let lock = ShardedLock::new(0isize);
+    let read_guard = lock.read().unwrap();
+
+    let write_result = lock.try_write();
+    match write_result {
+        Err(TryLockError::WouldBlock) => (),
+        Ok(_) => assert!(
+            false,
+            "try_write should not succeed while read_guard is in scope"
+        ),
+        Err(_) => assert!(false, "unexpected error"),
+    }
+
+    drop(read_guard);
+}
+
+#[test]
+fn test_into_inner() {
+    let m = ShardedLock::new(NonCopy(10));
+    assert_eq!(m.into_inner().unwrap(), NonCopy(10));
+}
+
+#[test]
+fn test_into_inner_drop() {
+    struct Foo(Arc<AtomicUsize>);
+    impl Drop for Foo {
+        fn drop(&mut self) {
+            self.0.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+    let num_drops = Arc::new(AtomicUsize::new(0));
+    let m = ShardedLock::new(Foo(num_drops.clone()));
+    assert_eq!(num_drops.load(Ordering::SeqCst), 0);
+    {
+        let _inner = m.into_inner().unwrap();
+        assert_eq!(num_drops.load(Ordering::SeqCst), 0);
+    }
+    assert_eq!(num_drops.load(Ordering::SeqCst), 1);
+}
+
+#[test]
+fn test_into_inner_poison() {
+    let m = Arc::new(ShardedLock::new(NonCopy(10)));
+    let m2 = m.clone();
+    let _ = thread::spawn(move || {
+        let _lock = m2.write().unwrap();
+        panic!("test panic in inner thread to poison ShardedLock");
+    })
+    .join();
+
+    assert!(m.is_poisoned());
+    match Arc::try_unwrap(m).unwrap().into_inner() {
+        Err(e) => assert_eq!(e.into_inner(), NonCopy(10)),
+        Ok(x) => panic!("into_inner of poisoned ShardedLock is Ok: {:?}", x),
+    }
+}
+
+#[test]
+fn test_get_mut() {
+    let mut m = ShardedLock::new(NonCopy(10));
+    *m.get_mut().unwrap() = NonCopy(20);
+    assert_eq!(m.into_inner().unwrap(), NonCopy(20));
+}
+
+#[test]
+fn test_get_mut_poison() {
+    let m = Arc::new(ShardedLock::new(NonCopy(10)));
+    let m2 = m.clone();
+    let _ = thread::spawn(move || {
+        let _lock = m2.write().unwrap();
+        panic!("test panic in inner thread to poison ShardedLock");
+    })
+    .join();
+
+    assert!(m.is_poisoned());
+    match Arc::try_unwrap(m).unwrap().get_mut() {
+        Err(e) => assert_eq!(*e.into_inner(), NonCopy(10)),
+        Ok(x) => panic!("get_mut of poisoned ShardedLock is Ok: {:?}", x),
+    }
+}
diff --git a/third_party/rust/crossbeam-utils-0.6.6/tests/thread.rs b/third_party/rust/crossbeam-utils-0.6.6/tests/thread.rs
new file mode 100644
index 0000000000..b691745e0b
--- /dev/null
+++ b/third_party/rust/crossbeam-utils-0.6.6/tests/thread.rs
@@ -0,0 +1,181 @@
+extern crate crossbeam_utils;
+
+use std::any::Any;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::thread::sleep;
+use std::time::Duration;
+
+use crossbeam_utils::thread;
+
+const THREADS: usize = 10;
+const SMALL_STACK_SIZE: usize = 20;
+
+#[test]
+fn join() {
+    let counter = AtomicUsize::new(0);
+    thread::scope(|scope| {
+        let handle = scope.spawn(|_| {
+            counter.store(1, Ordering::Relaxed);
+        });
+        assert!(handle.join().is_ok());
+
+        let panic_handle = scope.spawn(|_| {
+            panic!("\"My honey is running out!\", said Pooh.");
+        });
+        assert!(panic_handle.join().is_err());
+    })
+    .unwrap();
+
+    // There should be sufficient synchronization.
+    assert_eq!(1, counter.load(Ordering::Relaxed));
+}
+
+#[test]
+fn counter() {
+    let counter = AtomicUsize::new(0);
+    thread::scope(|scope| {
+        for _ in 0..THREADS {
+            scope.spawn(|_| {
+                counter.fetch_add(1, Ordering::Relaxed);
+            });
+        }
+    })
+    .unwrap();
+
+    assert_eq!(THREADS, counter.load(Ordering::Relaxed));
+}
+
+#[test]
+fn counter_builder() {
+    let counter = AtomicUsize::new(0);
+    thread::scope(|scope| {
+        for i in 0..THREADS {
+            scope
+                .builder()
+                .name(format!("child-{}", i))
+                .stack_size(SMALL_STACK_SIZE)
+                .spawn(|_| {
+                    counter.fetch_add(1, Ordering::Relaxed);
+                })
+                .unwrap();
+        }
+    })
+    .unwrap();
+
+    assert_eq!(THREADS, counter.load(Ordering::Relaxed));
+}
+
+#[test]
+fn counter_panic() {
+    let counter = AtomicUsize::new(0);
+    let result = thread::scope(|scope| {
+        scope.spawn(|_| {
+            panic!("\"My honey is running out!\", said Pooh.");
+        });
+        sleep(Duration::from_millis(100));
+
+        for _ in 0..THREADS {
+            scope.spawn(|_| {
+                counter.fetch_add(1, Ordering::Relaxed);
+            });
+        }
+    });
+
+    assert_eq!(THREADS, counter.load(Ordering::Relaxed));
+    assert!(result.is_err());
+}
+
+#[test]
+fn panic_twice() {
+    let result = thread::scope(|scope| {
+        scope.spawn(|_| {
+            sleep(Duration::from_millis(500));
+            panic!("thread #1");
+        });
+        scope.spawn(|_| {
+            panic!("thread #2");
+        });
+    });
+
+    let err = result.unwrap_err();
+    let vec = err
+        .downcast_ref::<Vec<Box<Any + Send + 'static>>>()
+        .unwrap();
+    assert_eq!(2, vec.len());
+
+    let first = vec[0].downcast_ref::<&str>().unwrap();
+    let second = vec[1].downcast_ref::<&str>().unwrap();
+    assert_eq!("thread #1", *first);
+    assert_eq!("thread #2", *second)
+}
+
+#[test]
+fn panic_many() {
+    let result = thread::scope(|scope| {
+        scope.spawn(|_| panic!("deliberate panic #1"));
+        scope.spawn(|_| panic!("deliberate panic #2"));
+        scope.spawn(|_| panic!("deliberate panic #3"));
+    });
+
+    let err = result.unwrap_err();
+    let vec = err
+        .downcast_ref::<Vec<Box<Any + Send + 'static>>>()
+        .unwrap();
+    assert_eq!(3, vec.len());
+
+    for panic in vec.iter() {
+        let panic = panic.downcast_ref::<&str>().unwrap();
+        assert!(
+            *panic == "deliberate panic #1"
+                || *panic == "deliberate panic #2"
+                || *panic == "deliberate panic #3"
+        );
+    }
+}
+
+#[test]
+fn nesting() {
+    let var = "foo".to_string();
+
+    struct Wrapper<'a> {
+        var: &'a String,
+    }
+
+    impl<'a> Wrapper<'a> {
+        fn recurse(&'a self, scope: &thread::Scope<'a>, depth: usize) {
+            assert_eq!(self.var, "foo");
+
+            if depth > 0 {
+                scope.spawn(move |scope| {
+                    self.recurse(scope, depth - 1);
+                });
+            }
+        }
+    }
+
+    let wrapper = Wrapper { var: &var };
+
+    thread::scope(|scope| {
+        scope.spawn(|scope| {
+            scope.spawn(|scope| {
+                wrapper.recurse(scope, 5);
+            });
+        });
+    })
+    .unwrap();
+}
+
+#[test]
+fn join_nested() {
+    thread::scope(|scope| {
+        scope.spawn(|scope| {
+            let handle = scope.spawn(|_| 7);
+
+            sleep(Duration::from_millis(200));
+            handle.join().unwrap();
+        });
+
+        sleep(Duration::from_millis(100));
+    })
+    .unwrap();
+}
diff --git a/third_party/rust/crossbeam-utils-0.6.6/tests/wait_group.rs b/third_party/rust/crossbeam-utils-0.6.6/tests/wait_group.rs
new file mode 100644
index 0000000000..1aa91997af
--- /dev/null
+++ b/third_party/rust/crossbeam-utils-0.6.6/tests/wait_group.rs
@@ -0,0 +1,66 @@
+extern crate crossbeam_utils;
+
+use std::sync::mpsc;
+use std::thread;
+use std::time::Duration;
+
+use crossbeam_utils::sync::WaitGroup;
+
+const THREADS: usize = 10;
+
+#[test]
+fn wait() {
+    let wg = WaitGroup::new();
+    let (tx, rx) = mpsc::channel();
+
+    for _ in 0..THREADS {
+        let wg = wg.clone();
+        let tx = tx.clone();
+
+        thread::spawn(move || {
+            wg.wait();
+            tx.send(()).unwrap();
+        });
+    }
+
+    thread::sleep(Duration::from_millis(100));
+
+    // At this point, all spawned threads should be blocked, so we shouldn't get anything from the
+    // channel.
+    assert!(rx.try_recv().is_err());
+
+    wg.wait();
+
+    // Now, the wait group is cleared and we should receive messages.
+    for _ in 0..THREADS {
+        rx.recv().unwrap();
+    }
+}
+
+#[test]
+fn wait_and_drop() {
+    let wg = WaitGroup::new();
+    let (tx, rx) = mpsc::channel();
+
+    for _ in 0..THREADS {
+        let wg = wg.clone();
+        let tx = tx.clone();
+
+        thread::spawn(move || {
+            thread::sleep(Duration::from_millis(100));
+            tx.send(()).unwrap();
+            drop(wg);
+        });
+    }
+
+    // At this point, all spawned threads should be sleeping, so we shouldn't get anything from the
+    // channel.
+    assert!(rx.try_recv().is_err());
+
+    wg.wait();
+
+    // Now, the wait group is cleared and we should receive messages.
+    for _ in 0..THREADS {
+        rx.try_recv().unwrap();
+    }
+}