rollup merge of #20273: alexcrichton/second-pass-comm
Conflicts: src/doc/guide.md src/libcollections/bit.rs src/libcollections/btree/node.rs src/libcollections/slice.rs src/libcore/ops.rs src/libcore/prelude.rs src/librand/rand_impls.rs src/librustc/middle/check_match.rs src/librustc/middle/infer/region_inference/mod.rs src/librustc_driver/lib.rs src/librustdoc/test.rs src/libstd/bitflags.rs src/libstd/io/comm_adapters.rs src/libstd/io/mem.rs src/libstd/io/mod.rs src/libstd/io/net/pipe.rs src/libstd/io/net/tcp.rs src/libstd/io/net/udp.rs src/libstd/io/pipe.rs src/libstd/io/process.rs src/libstd/io/stdio.rs src/libstd/io/timer.rs src/libstd/io/util.rs src/libstd/macros.rs src/libstd/os.rs src/libstd/path/posix.rs src/libstd/path/windows.rs src/libstd/prelude/v1.rs src/libstd/rand/mod.rs src/libstd/rand/os.rs src/libstd/sync/barrier.rs src/libstd/sync/condvar.rs src/libstd/sync/future.rs src/libstd/sync/mpsc/mod.rs src/libstd/sync/mpsc/mpsc_queue.rs src/libstd/sync/mpsc/select.rs src/libstd/sync/mpsc/spsc_queue.rs src/libstd/sync/mutex.rs src/libstd/sync/once.rs src/libstd/sync/rwlock.rs src/libstd/sync/semaphore.rs src/libstd/sync/task_pool.rs src/libstd/sys/common/helper_thread.rs src/libstd/sys/unix/process.rs src/libstd/sys/unix/timer.rs src/libstd/sys/windows/c.rs src/libstd/sys/windows/timer.rs src/libstd/sys/windows/tty.rs src/libstd/thread.rs src/libstd/thread_local/mod.rs src/libstd/thread_local/scoped.rs src/libtest/lib.rs src/test/auxiliary/cci_capture_clause.rs src/test/bench/shootout-reverse-complement.rs src/test/bench/shootout-spectralnorm.rs src/test/compile-fail/array-old-syntax-2.rs src/test/compile-fail/bind-by-move-no-guards.rs src/test/compile-fail/builtin-superkinds-self-type.rs src/test/compile-fail/comm-not-freeze-receiver.rs src/test/compile-fail/comm-not-freeze.rs src/test/compile-fail/issue-12041.rs src/test/compile-fail/unsendable-class.rs src/test/run-pass/builtin-superkinds-capabilities-transitive.rs src/test/run-pass/builtin-superkinds-capabilities-xc.rs src/test/run-pass/builtin-superkinds-capabilities.rs src/test/run-pass/builtin-superkinds-self-type.rs src/test/run-pass/capturing-logging.rs src/test/run-pass/closure-bounds-can-capture-chan.rs src/test/run-pass/comm.rs src/test/run-pass/core-run-destroy.rs src/test/run-pass/drop-trait-enum.rs src/test/run-pass/hashmap-memory.rs src/test/run-pass/issue-13494.rs src/test/run-pass/issue-3609.rs src/test/run-pass/issue-4446.rs src/test/run-pass/issue-4448.rs src/test/run-pass/issue-8827.rs src/test/run-pass/issue-9396.rs src/test/run-pass/ivec-tag.rs src/test/run-pass/rust-log-filter.rs src/test/run-pass/send-resource.rs src/test/run-pass/send-type-inference.rs src/test/run-pass/sendable-class.rs src/test/run-pass/spawn-types.rs src/test/run-pass/task-comm-0.rs src/test/run-pass/task-comm-10.rs src/test/run-pass/task-comm-11.rs src/test/run-pass/task-comm-13.rs src/test/run-pass/task-comm-14.rs src/test/run-pass/task-comm-15.rs src/test/run-pass/task-comm-16.rs src/test/run-pass/task-comm-3.rs src/test/run-pass/task-comm-4.rs src/test/run-pass/task-comm-5.rs src/test/run-pass/task-comm-6.rs src/test/run-pass/task-comm-7.rs src/test/run-pass/task-comm-9.rs src/test/run-pass/task-comm-chan-nil.rs src/test/run-pass/task-spawn-move-and-copy.rs src/test/run-pass/task-stderr.rs src/test/run-pass/tcp-accept-stress.rs src/test/run-pass/tcp-connect-timeouts.rs src/test/run-pass/tempfile.rs src/test/run-pass/trait-bounds-in-arc.rs src/test/run-pass/trivial-message.rs src/test/run-pass/unique-send-2.rs src/test/run-pass/unique-send.rs src/test/run-pass/unwind-resource.rs
This commit is contained in:
Alex Crichton
commit
8b7d032014
111 changed files with 1138 additions and 1160 deletions
|
|
@ -3174,6 +3174,7 @@ then the expression completes.
|
|||
Some examples of call expressions:
|
||||
|
||||
```
|
||||
# use std::str::from_str;
|
||||
# fn add(x: int, y: int) -> int { 0 }
|
||||
|
||||
let x: int = add(1, 2);
|
||||
|
|
|
|||
|
|
@ -38,8 +38,8 @@ exceptions = [
|
|||
"rt/isaac/randport.cpp", # public domain
|
||||
"rt/isaac/rand.h", # public domain
|
||||
"rt/isaac/standard.h", # public domain
|
||||
"libstd/comm/mpsc_queue.rs", # BSD
|
||||
"libstd/comm/spsc_queue.rs", # BSD
|
||||
"libstd/sync/mpsc/mpsc_queue.rs", # BSD
|
||||
"libstd/sync/mpsc/spsc_queue.rs", # BSD
|
||||
"test/bench/shootout-binarytrees.rs", # BSD
|
||||
"test/bench/shootout-chameneos-redux.rs", # BSD
|
||||
"test/bench/shootout-fannkuch-redux.rs", # BSD
|
||||
|
|
|
|||
|
|
@ -593,7 +593,7 @@ impl<T: Default + Sync + Send> Default for Arc<T> {
|
|||
#[allow(experimental)]
|
||||
mod tests {
|
||||
use std::clone::Clone;
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
use std::mem::drop;
|
||||
use std::ops::Drop;
|
||||
use std::option::Option;
|
||||
|
|
@ -630,11 +630,11 @@ mod tests {
|
|||
let (tx, rx) = channel();
|
||||
|
||||
task::spawn(move || {
|
||||
let arc_v: Arc<Vec<int>> = rx.recv();
|
||||
let arc_v: Arc<Vec<int>> = rx.recv().unwrap();
|
||||
assert_eq!((*arc_v)[3], 4);
|
||||
});
|
||||
|
||||
tx.send(arc_v.clone());
|
||||
tx.send(arc_v.clone()).unwrap();
|
||||
|
||||
assert_eq!((*arc_v)[2], 3);
|
||||
assert_eq!((*arc_v)[4], 5);
|
||||
|
|
|
|||
|
|
@ -87,8 +87,9 @@ use core::cmp;
|
|||
use core::default::Default;
|
||||
use core::fmt;
|
||||
use core::hash;
|
||||
use core::iter::{Cloned, Chain, Enumerate, Repeat, Skip, Take, repeat};
|
||||
use core::iter::{mod, FromIterator, RandomAccessIterator};
|
||||
use core::iter::RandomAccessIterator;
|
||||
use core::iter::{Chain, Enumerate, Repeat, Skip, Take, repeat, Cloned};
|
||||
use core::iter::{mod, FromIterator};
|
||||
use core::num::Int;
|
||||
use core::ops::Index;
|
||||
use core::slice::{Iter, IterMut};
|
||||
|
|
|
|||
|
|
@ -723,6 +723,8 @@ impl<T: Default> Option<T> {
|
|||
/// `None` on error.
|
||||
///
|
||||
/// ```
|
||||
/// use std::str::from_str;
|
||||
///
|
||||
/// let good_year_from_input = "1909";
|
||||
/// let bad_year_from_input = "190blarg";
|
||||
/// let good_year = good_year_from_input.parse().unwrap_or_default();
|
||||
|
|
|
|||
|
|
@ -449,6 +449,7 @@ impl<T, E> Result<T, E> {
|
|||
///
|
||||
/// ```
|
||||
/// use std::io::IoResult;
|
||||
/// use std::str::from_str;
|
||||
///
|
||||
/// let mut buffer = &mut b"1\n2\n3\n4\n";
|
||||
///
|
||||
|
|
|
|||
|
|
@ -55,10 +55,10 @@ use rustc::DIAGNOSTICS;
|
|||
|
||||
use std::any::AnyRefExt;
|
||||
use std::cmp::Ordering::Equal;
|
||||
use std::comm::channel;
|
||||
use std::io;
|
||||
use std::iter::repeat;
|
||||
use std::os;
|
||||
use std::sync::mpsc::channel;
|
||||
use std::thread;
|
||||
|
||||
use rustc::session::early_error;
|
||||
|
|
|
|||
|
|
@ -31,6 +31,7 @@ use std::ptr;
|
|||
use std::str;
|
||||
use std::mem;
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::sync::mpsc::channel;
|
||||
use std::thread;
|
||||
use libc::{c_uint, c_int, c_void};
|
||||
|
||||
|
|
@ -929,13 +930,13 @@ fn run_work_multithreaded(sess: &Session,
|
|||
}
|
||||
}
|
||||
|
||||
tx.take().unwrap().send(());
|
||||
tx.take().unwrap().send(()).unwrap();
|
||||
}).detach();
|
||||
}
|
||||
|
||||
let mut panicked = false;
|
||||
for rx in futures.into_iter() {
|
||||
match rx.recv_opt() {
|
||||
match rx.recv() {
|
||||
Ok(()) => {},
|
||||
Err(_) => {
|
||||
panicked = true;
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
// except according to those terms.
|
||||
|
||||
use std::cell::RefCell;
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
use std::dynamic_lib::DynamicLibrary;
|
||||
use std::io::{Command, TempDir};
|
||||
use std::io;
|
||||
|
|
|
|||
|
|
@ -266,7 +266,6 @@ macro_rules! bitflags {
|
|||
mod tests {
|
||||
use hash;
|
||||
use option::Option::{Some, None};
|
||||
use ops::{BitOr, BitAnd, BitXor, Sub, Not};
|
||||
|
||||
bitflags! {
|
||||
#[doc = "> The first principle is that you must not fool yourself — and"]
|
||||
|
|
|
|||
|
|
@ -623,7 +623,7 @@ mod tests {
|
|||
#[test]
|
||||
fn test_unwrap() {
|
||||
let c_str = "hello".to_c_str();
|
||||
unsafe { libc::free(c_str.unwrap() as *mut libc::c_void) }
|
||||
unsafe { libc::free(c_str.into_inner() as *mut libc::c_void) }
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -228,7 +228,7 @@ mod tests {
|
|||
let cv = CVec::new_with_dtor(1 as *mut int,
|
||||
0,
|
||||
move|:| panic!("Don't run this destructor!"));
|
||||
let p = cv.unwrap();
|
||||
let p = cv.into_inner();
|
||||
assert_eq!(p, 1 as *mut int);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1542,6 +1542,7 @@ mod test_map {
|
|||
|
||||
struct KindaIntLike(int);
|
||||
|
||||
#[allow(deprecated)]
|
||||
impl Equiv<int> for KindaIntLike {
|
||||
fn equiv(&self, other: &int) -> bool {
|
||||
let KindaIntLike(this) = *self;
|
||||
|
|
@ -1869,7 +1870,7 @@ mod test_map {
|
|||
}
|
||||
|
||||
#[test]
|
||||
#[allow(experimental)]
|
||||
#[allow(deprecated)]
|
||||
fn test_pop_equiv() {
|
||||
let mut m = HashMap::new();
|
||||
m.insert(1i, 2i);
|
||||
|
|
|
|||
|
|
@ -534,7 +534,7 @@ mod test {
|
|||
w.write(&[0, 1]).unwrap();
|
||||
let a: &[_] = &[];
|
||||
assert_eq!(a, w.get_ref()[]);
|
||||
let w = w.unwrap();
|
||||
let w = w.into_inner();
|
||||
let a: &[_] = &[0, 1];
|
||||
assert_eq!(a, w[]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
use clone::Clone;
|
||||
use cmp;
|
||||
use comm::{Sender, Receiver};
|
||||
use sync::mpsc::{Sender, Receiver};
|
||||
use io;
|
||||
use option::Option::{None, Some};
|
||||
use result::Result::{Ok, Err};
|
||||
|
|
@ -23,7 +23,7 @@ use vec::Vec;
|
|||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// use std::comm::channel;
|
||||
/// use std::sync::mpsc::channel;
|
||||
/// use std::io::ChanReader;
|
||||
///
|
||||
/// let (tx, rx) = channel();
|
||||
|
|
@ -59,11 +59,11 @@ impl Buffer for ChanReader {
|
|||
fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
|
||||
if self.pos >= self.buf.len() {
|
||||
self.pos = 0;
|
||||
match self.rx.recv_opt() {
|
||||
match self.rx.recv() {
|
||||
Ok(bytes) => {
|
||||
self.buf = bytes;
|
||||
},
|
||||
Err(()) => {
|
||||
Err(..) => {
|
||||
self.closed = true;
|
||||
self.buf = Vec::new();
|
||||
}
|
||||
|
|
@ -115,7 +115,7 @@ impl Reader for ChanReader {
|
|||
///
|
||||
/// ```
|
||||
/// # #![allow(unused_must_use)]
|
||||
/// use std::comm::channel;
|
||||
/// use std::sync::mpsc::channel;
|
||||
/// use std::io::ChanWriter;
|
||||
///
|
||||
/// let (tx, rx) = channel();
|
||||
|
|
@ -143,7 +143,7 @@ impl Clone for ChanWriter {
|
|||
|
||||
impl Writer for ChanWriter {
|
||||
fn write(&mut self, buf: &[u8]) -> IoResult<()> {
|
||||
self.tx.send_opt(buf.to_vec()).map_err(|_| {
|
||||
self.tx.send(buf.to_vec()).map_err(|_| {
|
||||
io::IoError {
|
||||
kind: io::BrokenPipe,
|
||||
desc: "Pipe closed",
|
||||
|
|
@ -158,7 +158,7 @@ impl Writer for ChanWriter {
|
|||
mod test {
|
||||
use prelude::v1::*;
|
||||
|
||||
use comm::channel;
|
||||
use sync::mpsc::channel;
|
||||
use super::*;
|
||||
use io;
|
||||
use thread::Thread;
|
||||
|
|
@ -167,11 +167,11 @@ mod test {
|
|||
fn test_rx_reader() {
|
||||
let (tx, rx) = channel();
|
||||
Thread::spawn(move|| {
|
||||
tx.send(vec![1u8, 2u8]);
|
||||
tx.send(vec![]);
|
||||
tx.send(vec![3u8, 4u8]);
|
||||
tx.send(vec![5u8, 6u8]);
|
||||
tx.send(vec![7u8, 8u8]);
|
||||
tx.send(vec![1u8, 2u8]).unwrap();
|
||||
tx.send(vec![]).unwrap();
|
||||
tx.send(vec![3u8, 4u8]).unwrap();
|
||||
tx.send(vec![5u8, 6u8]).unwrap();
|
||||
tx.send(vec![7u8, 8u8]).unwrap();
|
||||
}).detach();
|
||||
|
||||
let mut reader = ChanReader::new(rx);
|
||||
|
|
@ -209,12 +209,12 @@ mod test {
|
|||
fn test_rx_buffer() {
|
||||
let (tx, rx) = channel();
|
||||
Thread::spawn(move|| {
|
||||
tx.send(b"he".to_vec());
|
||||
tx.send(b"llo wo".to_vec());
|
||||
tx.send(b"".to_vec());
|
||||
tx.send(b"rld\nhow ".to_vec());
|
||||
tx.send(b"are you?".to_vec());
|
||||
tx.send(b"".to_vec());
|
||||
tx.send(b"he".to_vec()).unwrap();
|
||||
tx.send(b"llo wo".to_vec()).unwrap();
|
||||
tx.send(b"".to_vec()).unwrap();
|
||||
tx.send(b"rld\nhow ".to_vec()).unwrap();
|
||||
tx.send(b"are you?".to_vec()).unwrap();
|
||||
tx.send(b"".to_vec()).unwrap();
|
||||
}).detach();
|
||||
|
||||
let mut reader = ChanReader::new(rx);
|
||||
|
|
@ -234,7 +234,7 @@ mod test {
|
|||
writer.write_be_u32(42).unwrap();
|
||||
|
||||
let wanted = vec![0u8, 0u8, 0u8, 42u8];
|
||||
let got = match Thread::spawn(move|| { rx.recv() }).join() {
|
||||
let got = match Thread::spawn(move|| { rx.recv().unwrap() }).join() {
|
||||
Ok(got) => got,
|
||||
Err(_) => panic!(),
|
||||
};
|
||||
|
|
|
|||
|
|
@ -402,8 +402,8 @@ mod test {
|
|||
use prelude::v1::*;
|
||||
|
||||
use super::*;
|
||||
use io::{SeekSet, SeekCur, SeekEnd};
|
||||
use io;
|
||||
use io::{SeekSet, SeekCur, SeekEnd};
|
||||
use self::test_crate::Bencher;
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -1918,7 +1918,7 @@ impl fmt::Show for FilePermission {
|
|||
#[cfg(test)]
|
||||
mod tests {
|
||||
use self::BadReaderBehavior::*;
|
||||
use super::{IoResult, MemReader, NoProgress, InvalidInput};
|
||||
use super::{IoResult, Reader, MemReader, NoProgress, InvalidInput};
|
||||
use prelude::v1::*;
|
||||
use uint;
|
||||
|
||||
|
|
|
|||
|
|
@ -267,13 +267,13 @@ impl sys_common::AsInner<UnixAcceptorImp> for UnixAcceptor {
|
|||
mod tests {
|
||||
use prelude::v1::*;
|
||||
|
||||
use comm::channel;
|
||||
use io::fs::PathExtensions;
|
||||
use io::{EndOfFile, TimedOut, ShortWrite, IoError, ConnectionReset};
|
||||
use io::{NotConnected, BrokenPipe, OtherIoError, FileNotFound, InvalidInput};
|
||||
use io::{NotConnected, BrokenPipe, FileNotFound, InvalidInput, OtherIoError};
|
||||
use io::{PermissionDenied, Acceptor, Listener};
|
||||
use io::test::*;
|
||||
use super::*;
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
use time::Duration;
|
||||
|
||||
|
|
@ -433,18 +433,18 @@ mod tests {
|
|||
let (tx2, rx2) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
rx1.recv();
|
||||
rx1.recv().unwrap();
|
||||
debug!("writer writing");
|
||||
s2.write(&[1]).unwrap();
|
||||
debug!("writer done");
|
||||
tx2.send(());
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
tx1.send(());
|
||||
tx1.send(()).unwrap();
|
||||
let mut buf = [0, 0];
|
||||
debug!("reader reading");
|
||||
assert_eq!(s1.read(&mut buf), Ok(1));
|
||||
debug!("reader done");
|
||||
rx2.recv();
|
||||
rx2.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -457,9 +457,9 @@ mod tests {
|
|||
let _t = Thread::spawn(move|| {
|
||||
let mut s = UnixStream::connect(&addr);
|
||||
s.write(&[1]).unwrap();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
s.write(&[2]).unwrap();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
});
|
||||
|
||||
let mut s1 = acceptor.accept().unwrap();
|
||||
|
|
@ -470,14 +470,14 @@ mod tests {
|
|||
let mut s2 = s2;
|
||||
let mut buf = [0, 0];
|
||||
s2.read(&mut buf).unwrap();
|
||||
tx2.send(());
|
||||
done.send(());
|
||||
tx2.send(()).unwrap();
|
||||
done.send(()).unwrap();
|
||||
});
|
||||
let mut buf = [0, 0];
|
||||
s1.read(&mut buf).unwrap();
|
||||
tx1.send(());
|
||||
tx1.send(()).unwrap();
|
||||
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -499,11 +499,11 @@ mod tests {
|
|||
let _t = Thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
s2.write(&[1]).unwrap();
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
s1.write(&[2]).unwrap();
|
||||
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
|
|
@ -544,9 +544,9 @@ mod tests {
|
|||
let (tx, rx) = channel();
|
||||
let addr2 = addr.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
tx.send(UnixStream::connect(&addr2).unwrap());
|
||||
tx.send(UnixStream::connect(&addr2).unwrap()).unwrap();
|
||||
});
|
||||
let l = rx.recv();
|
||||
let l = rx.recv().unwrap();
|
||||
for i in range(0u, 1001) {
|
||||
match a.accept() {
|
||||
Ok(..) => break,
|
||||
|
|
@ -602,7 +602,7 @@ mod tests {
|
|||
Thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
let _s = a.accept().unwrap();
|
||||
let _ = rx.recv_opt();
|
||||
let _ = rx.recv();
|
||||
}).detach();
|
||||
|
||||
let mut b = [0];
|
||||
|
|
@ -639,7 +639,7 @@ mod tests {
|
|||
Thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
let _s = a.accept().unwrap();
|
||||
let _ = rx.recv_opt();
|
||||
let _ = rx.recv();
|
||||
}).detach();
|
||||
|
||||
let mut s = UnixStream::connect(&addr).unwrap();
|
||||
|
|
@ -648,13 +648,13 @@ mod tests {
|
|||
let _t = Thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
assert!(s2.read(&mut [0]).is_err());
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
// this should wake up the child task
|
||||
s.close_read().unwrap();
|
||||
|
||||
// this test will never finish if the child doesn't wake up
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -664,9 +664,9 @@ mod tests {
|
|||
let (tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
let mut s = UnixStream::connect(&addr).unwrap();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
assert!(s.write(&[0]).is_ok());
|
||||
let _ = rx.recv_opt();
|
||||
let _ = rx.recv();
|
||||
}).detach();
|
||||
|
||||
let mut s = a.accept().unwrap();
|
||||
|
|
@ -690,7 +690,7 @@ mod tests {
|
|||
assert_eq!(s.write(&[0]).err().unwrap().kind, TimedOut);
|
||||
}
|
||||
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
s.set_timeout(None);
|
||||
assert_eq!(s.read(&mut [0, 0]), Ok(1));
|
||||
}
|
||||
|
|
@ -702,7 +702,7 @@ mod tests {
|
|||
let (tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
let mut s = UnixStream::connect(&addr).unwrap();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
let mut amt = 0;
|
||||
while amt < 100 * 128 * 1024 {
|
||||
match s.read(&mut [0;128 * 1024]) {
|
||||
|
|
@ -710,7 +710,7 @@ mod tests {
|
|||
Err(e) => panic!("{}", e),
|
||||
}
|
||||
}
|
||||
let _ = rx.recv_opt();
|
||||
let _ = rx.recv();
|
||||
}).detach();
|
||||
|
||||
let mut s = a.accept().unwrap();
|
||||
|
|
@ -718,7 +718,7 @@ mod tests {
|
|||
assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
|
||||
assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
|
||||
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
for _ in range(0u, 100) {
|
||||
assert!(s.write(&[0;128 * 1024]).is_ok());
|
||||
}
|
||||
|
|
@ -731,9 +731,9 @@ mod tests {
|
|||
let (tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
let mut s = UnixStream::connect(&addr).unwrap();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
assert!(s.write(&[0]).is_ok());
|
||||
let _ = rx.recv_opt();
|
||||
let _ = rx.recv();
|
||||
}).detach();
|
||||
|
||||
let mut s = a.accept().unwrap();
|
||||
|
|
@ -747,7 +747,7 @@ mod tests {
|
|||
if i == 1000 { panic!("should have filled up?!"); }
|
||||
}
|
||||
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
assert!(s.read(&mut [0]).is_ok());
|
||||
}
|
||||
|
||||
|
|
@ -758,9 +758,9 @@ mod tests {
|
|||
let (tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
let mut s = UnixStream::connect(&addr).unwrap();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
assert!(s.write(&[0]).is_ok());
|
||||
let _ = rx.recv_opt();
|
||||
let _ = rx.recv();
|
||||
}).detach();
|
||||
|
||||
let mut s = a.accept().unwrap();
|
||||
|
|
@ -769,14 +769,14 @@ mod tests {
|
|||
let _t = Thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
assert!(s2.read(&mut [0]).is_ok());
|
||||
tx2.send(());
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
|
||||
s.set_read_timeout(Some(20));
|
||||
assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
|
||||
rx2.recv();
|
||||
rx2.recv().unwrap();
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
|
|
@ -811,8 +811,14 @@ mod tests {
|
|||
let (tx, rx) = channel();
|
||||
let tx2 = tx.clone();
|
||||
|
||||
let _t = Thread::spawn(move|| { let mut a = a; tx.send(a.accept()) });
|
||||
let _t = Thread::spawn(move|| { let mut a = a2; tx2.send(a.accept()) });
|
||||
let _t = Thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
tx.send(a.accept()).unwrap()
|
||||
});
|
||||
let _t = Thread::spawn(move|| {
|
||||
let mut a = a2;
|
||||
tx2.send(a.accept()).unwrap()
|
||||
});
|
||||
|
||||
let addr2 = addr.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
|
|
@ -822,8 +828,8 @@ mod tests {
|
|||
let _ = UnixStream::connect(&addr);
|
||||
});
|
||||
|
||||
assert!(rx.recv().is_ok());
|
||||
assert!(rx.recv().is_ok());
|
||||
assert!(rx.recv().unwrap().is_ok());
|
||||
assert!(rx.recv().unwrap().is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -846,10 +852,10 @@ mod tests {
|
|||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
tx.send(a.accept());
|
||||
tx.send(a.accept()).unwrap();
|
||||
});
|
||||
a2.close_accept().unwrap();
|
||||
|
||||
assert_eq!(rx.recv().err().unwrap().kind, EndOfFile);
|
||||
assert_eq!(rx.recv().unwrap().err().unwrap().kind, EndOfFile);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -484,14 +484,15 @@ impl sys_common::AsInner<TcpAcceptorImp> for TcpAcceptor {
|
|||
mod test {
|
||||
use prelude::v1::*;
|
||||
|
||||
use comm::channel;
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
use io::net::tcp::*;
|
||||
use io::net::ip::*;
|
||||
use io::{EndOfFile, TimedOut, IoError, ShortWrite, OtherIoError, ConnectionAborted};
|
||||
use io::{ConnectionRefused, ConnectionReset, BrokenPipe, NotConnected};
|
||||
use io::{PermissionDenied, Listener, Acceptor};
|
||||
use io::test::*;
|
||||
use io::{EndOfFile, TimedOut, ShortWrite, IoError};
|
||||
use io::{ConnectionRefused, BrokenPipe, ConnectionAborted};
|
||||
use io::{ConnectionReset, NotConnected, PermissionDenied, OtherIoError};
|
||||
use io::{Acceptor, Listener};
|
||||
|
||||
// FIXME #11530 this fails on android because tests are run as root
|
||||
#[cfg_attr(any(windows, target_os = "android"), ignore)]
|
||||
|
|
@ -696,11 +697,11 @@ mod test {
|
|||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
drop(TcpStream::connect(addr));
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
|
||||
let mut stream = acceptor.accept();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
let buf = [0];
|
||||
match stream.write(&buf) {
|
||||
Ok(..) => {}
|
||||
|
|
@ -721,11 +722,11 @@ mod test {
|
|||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
drop(TcpStream::connect(addr));
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
|
||||
let mut stream = acceptor.accept();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
let buf = [0];
|
||||
match stream.write(&buf) {
|
||||
Ok(..) => {}
|
||||
|
|
@ -971,20 +972,20 @@ mod test {
|
|||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let mut srv = TcpListener::bind(addr).listen().unwrap();
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
let mut cl = srv.accept().unwrap();
|
||||
cl.write(&[10]).unwrap();
|
||||
let mut b = [0];
|
||||
cl.read(&mut b).unwrap();
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
let mut c = TcpStream::connect(addr).unwrap();
|
||||
let mut b = [0; 10];
|
||||
assert_eq!(c.read(&mut b), Ok(1));
|
||||
c.write(&[1]).unwrap();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1007,19 +1008,19 @@ mod test {
|
|||
let (tx, rx) = channel();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
let _stream = TcpStream::connect(addr).unwrap();
|
||||
// Close
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
});
|
||||
|
||||
{
|
||||
let mut acceptor = TcpListener::bind(addr).listen();
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
{
|
||||
let _stream = acceptor.accept().unwrap();
|
||||
// Close client
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
}
|
||||
// Close listener
|
||||
}
|
||||
|
|
@ -1046,14 +1047,14 @@ mod test {
|
|||
let (tx2, rx2) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
rx1.recv();
|
||||
rx1.recv().unwrap();
|
||||
s2.write(&[1]).unwrap();
|
||||
tx2.send(());
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
tx1.send(());
|
||||
tx1.send(()).unwrap();
|
||||
let mut buf = [0, 0];
|
||||
assert_eq!(s1.read(&mut buf), Ok(1));
|
||||
rx2.recv();
|
||||
rx2.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1066,9 +1067,9 @@ mod test {
|
|||
let _t = Thread::spawn(move|| {
|
||||
let mut s = TcpStream::connect(addr);
|
||||
s.write(&[1]).unwrap();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
s.write(&[2]).unwrap();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
});
|
||||
|
||||
let mut s1 = acceptor.accept().unwrap();
|
||||
|
|
@ -1079,14 +1080,14 @@ mod test {
|
|||
let mut s2 = s2;
|
||||
let mut buf = [0, 0];
|
||||
s2.read(&mut buf).unwrap();
|
||||
tx2.send(());
|
||||
done.send(());
|
||||
tx2.send(()).unwrap();
|
||||
done.send(()).unwrap();
|
||||
});
|
||||
let mut buf = [0, 0];
|
||||
s1.read(&mut buf).unwrap();
|
||||
tx1.send(());
|
||||
tx1.send(()).unwrap();
|
||||
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1108,11 +1109,11 @@ mod test {
|
|||
let _t = Thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
s2.write(&[1]).unwrap();
|
||||
done.send(());
|
||||
done.send(()).unwrap();
|
||||
});
|
||||
s1.write(&[2]).unwrap();
|
||||
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1154,9 +1155,9 @@ mod test {
|
|||
if !cfg!(target_os = "freebsd") {
|
||||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
tx.send(TcpStream::connect(addr).unwrap());
|
||||
tx.send(TcpStream::connect(addr).unwrap()).unwrap();
|
||||
});
|
||||
let _l = rx.recv();
|
||||
let _l = rx.recv().unwrap();
|
||||
for i in range(0i, 1001) {
|
||||
match a.accept() {
|
||||
Ok(..) => break,
|
||||
|
|
@ -1184,7 +1185,7 @@ mod test {
|
|||
Thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
let _s = a.accept().unwrap();
|
||||
let _ = rx.recv_opt();
|
||||
let _ = rx.recv().unwrap();
|
||||
}).detach();
|
||||
|
||||
let mut b = [0];
|
||||
|
|
@ -1221,7 +1222,7 @@ mod test {
|
|||
Thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
let _s = a.accept().unwrap();
|
||||
let _ = rx.recv_opt();
|
||||
let _ = rx.recv().unwrap();
|
||||
}).detach();
|
||||
|
||||
let mut s = TcpStream::connect(addr).unwrap();
|
||||
|
|
@ -1230,13 +1231,13 @@ mod test {
|
|||
let _t = Thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
assert!(s2.read(&mut [0]).is_err());
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
// this should wake up the child task
|
||||
s.close_read().unwrap();
|
||||
|
||||
// this test will never finish if the child doesn't wake up
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1246,9 +1247,9 @@ mod test {
|
|||
let (tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
let mut s = TcpStream::connect(addr).unwrap();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
assert!(s.write(&[0]).is_ok());
|
||||
let _ = rx.recv_opt();
|
||||
let _ = rx.recv();
|
||||
}).detach();
|
||||
|
||||
let mut s = a.accept().unwrap();
|
||||
|
|
@ -1267,7 +1268,7 @@ mod test {
|
|||
}
|
||||
assert_eq!(s.write(&[0]).err().unwrap().kind, TimedOut);
|
||||
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
s.set_timeout(None);
|
||||
assert_eq!(s.read(&mut [0, 0]), Ok(1));
|
||||
}
|
||||
|
|
@ -1279,7 +1280,7 @@ mod test {
|
|||
let (tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
let mut s = TcpStream::connect(addr).unwrap();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
let mut amt = 0;
|
||||
while amt < 100 * 128 * 1024 {
|
||||
match s.read(&mut [0;128 * 1024]) {
|
||||
|
|
@ -1287,7 +1288,7 @@ mod test {
|
|||
Err(e) => panic!("{}", e),
|
||||
}
|
||||
}
|
||||
let _ = rx.recv_opt();
|
||||
let _ = rx.recv();
|
||||
}).detach();
|
||||
|
||||
let mut s = a.accept().unwrap();
|
||||
|
|
@ -1295,7 +1296,7 @@ mod test {
|
|||
assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
|
||||
assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
|
||||
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
for _ in range(0i, 100) {
|
||||
assert!(s.write(&[0;128 * 1024]).is_ok());
|
||||
}
|
||||
|
|
@ -1308,9 +1309,9 @@ mod test {
|
|||
let (tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
let mut s = TcpStream::connect(addr).unwrap();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
assert!(s.write(&[0]).is_ok());
|
||||
let _ = rx.recv_opt();
|
||||
let _ = rx.recv();
|
||||
}).detach();
|
||||
|
||||
let mut s = a.accept().unwrap();
|
||||
|
|
@ -1325,7 +1326,7 @@ mod test {
|
|||
}
|
||||
assert_eq!(s.write(&[0]).err().unwrap().kind, TimedOut);
|
||||
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
assert!(s.read(&mut [0]).is_ok());
|
||||
}
|
||||
|
||||
|
|
@ -1336,9 +1337,9 @@ mod test {
|
|||
let (tx, rx) = channel::<()>();
|
||||
Thread::spawn(move|| {
|
||||
let mut s = TcpStream::connect(addr).unwrap();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
assert_eq!(s.write(&[0]), Ok(()));
|
||||
let _ = rx.recv_opt();
|
||||
let _ = rx.recv();
|
||||
}).detach();
|
||||
|
||||
let mut s = a.accept().unwrap();
|
||||
|
|
@ -1347,14 +1348,14 @@ mod test {
|
|||
let _t = Thread::spawn(move|| {
|
||||
let mut s2 = s2;
|
||||
assert_eq!(s2.read(&mut [0]), Ok(1));
|
||||
tx2.send(());
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
|
||||
s.set_read_timeout(Some(20));
|
||||
assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
|
||||
rx2.recv();
|
||||
rx2.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1369,9 +1370,9 @@ mod test {
|
|||
let txdone2 = txdone.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let mut tcp = TcpStream::connect(addr).unwrap();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
tcp.write_u8(0).unwrap();
|
||||
txdone2.send(());
|
||||
txdone2.send(()).unwrap();
|
||||
});
|
||||
|
||||
// Spawn off a reading clone
|
||||
|
|
@ -1381,7 +1382,7 @@ mod test {
|
|||
let _t = Thread::spawn(move|| {
|
||||
let mut tcp2 = tcp2;
|
||||
tcp2.read_u8().unwrap();
|
||||
txdone3.send(());
|
||||
txdone3.send(()).unwrap();
|
||||
});
|
||||
|
||||
// Try to ensure that the reading clone is indeed reading
|
||||
|
|
@ -1392,9 +1393,9 @@ mod test {
|
|||
// clone the handle again while it's reading, then let it finish the
|
||||
// read.
|
||||
let _ = tcp.clone();
|
||||
tx.send(());
|
||||
rxdone.recv();
|
||||
rxdone.recv();
|
||||
tx.send(()).unwrap();
|
||||
rxdone.recv().unwrap();
|
||||
rxdone.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1425,8 +1426,14 @@ mod test {
|
|||
let (tx, rx) = channel();
|
||||
let tx2 = tx.clone();
|
||||
|
||||
let _t = Thread::spawn(move|| { let mut a = a; tx.send(a.accept()) });
|
||||
let _t = Thread::spawn(move|| { let mut a = a2; tx2.send(a.accept()) });
|
||||
let _t = Thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
tx.send(a.accept()).unwrap();
|
||||
});
|
||||
let _t = Thread::spawn(move|| {
|
||||
let mut a = a2;
|
||||
tx2.send(a.accept()).unwrap();
|
||||
});
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
let _ = TcpStream::connect(addr);
|
||||
|
|
@ -1435,8 +1442,8 @@ mod test {
|
|||
let _ = TcpStream::connect(addr);
|
||||
});
|
||||
|
||||
assert!(rx.recv().is_ok());
|
||||
assert!(rx.recv().is_ok());
|
||||
assert!(rx.recv().unwrap().is_ok());
|
||||
assert!(rx.recv().unwrap().is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1459,10 +1466,10 @@ mod test {
|
|||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let mut a = a;
|
||||
tx.send(a.accept());
|
||||
tx.send(a.accept()).unwrap();
|
||||
});
|
||||
a2.close_accept().unwrap();
|
||||
|
||||
assert_eq!(rx.recv().err().unwrap().kind, EndOfFile);
|
||||
assert_eq!(rx.recv().unwrap().err().unwrap().kind, EndOfFile);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -250,10 +250,10 @@ impl Writer for UdpStream {
|
|||
mod test {
|
||||
use prelude::v1::*;
|
||||
|
||||
use comm::channel;
|
||||
use sync::mpsc::channel;
|
||||
use io::net::ip::*;
|
||||
use io::{IoError, ShortWrite, TimedOut, PermissionDenied};
|
||||
use io::test::*;
|
||||
use io::{IoError, TimedOut, PermissionDenied, ShortWrite};
|
||||
use super::*;
|
||||
use thread::Thread;
|
||||
|
||||
|
|
@ -278,17 +278,17 @@ mod test {
|
|||
let _t = Thread::spawn(move|| {
|
||||
match UdpSocket::bind(client_ip) {
|
||||
Ok(ref mut client) => {
|
||||
rx1.recv();
|
||||
rx1.recv().unwrap();
|
||||
client.send_to(&[99], server_ip).unwrap()
|
||||
}
|
||||
Err(..) => panic!()
|
||||
}
|
||||
tx2.send(());
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
|
||||
match UdpSocket::bind(server_ip) {
|
||||
Ok(ref mut server) => {
|
||||
tx1.send(());
|
||||
tx1.send(()).unwrap();
|
||||
let mut buf = [0];
|
||||
match server.recv_from(&mut buf) {
|
||||
Ok((nread, src)) => {
|
||||
|
|
@ -301,7 +301,7 @@ mod test {
|
|||
}
|
||||
Err(..) => panic!()
|
||||
}
|
||||
rx2.recv();
|
||||
rx2.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -313,7 +313,7 @@ mod test {
|
|||
let _t = Thread::spawn(move|| {
|
||||
match UdpSocket::bind(client_ip) {
|
||||
Ok(ref mut client) => {
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
client.send_to(&[99], server_ip).unwrap()
|
||||
}
|
||||
Err(..) => panic!()
|
||||
|
|
@ -322,7 +322,7 @@ mod test {
|
|||
|
||||
match UdpSocket::bind(server_ip) {
|
||||
Ok(ref mut server) => {
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
let mut buf = [0];
|
||||
match server.recv_from(&mut buf) {
|
||||
Ok((nread, src)) => {
|
||||
|
|
@ -357,17 +357,17 @@ mod test {
|
|||
Err(..) => panic!()
|
||||
}
|
||||
};
|
||||
rx1.recv();
|
||||
rx1.recv().unwrap();
|
||||
send_as(dummy_ip, &[98]);
|
||||
send_as(client_ip, &[99]);
|
||||
tx2.send(());
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
|
||||
match UdpSocket::bind(server_ip) {
|
||||
Ok(server) => {
|
||||
let server = box server;
|
||||
let mut stream = server.connect(client_ip);
|
||||
tx1.send(());
|
||||
tx1.send(()).unwrap();
|
||||
let mut buf = [0];
|
||||
match stream.read(&mut buf) {
|
||||
Ok(nread) => {
|
||||
|
|
@ -379,7 +379,7 @@ mod test {
|
|||
}
|
||||
Err(..) => panic!()
|
||||
}
|
||||
rx2.recv();
|
||||
rx2.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -395,19 +395,19 @@ mod test {
|
|||
Ok(client) => {
|
||||
let client = box client;
|
||||
let mut stream = client.connect(server_ip);
|
||||
rx1.recv();
|
||||
rx1.recv().unwrap();
|
||||
stream.write(&[99]).unwrap();
|
||||
}
|
||||
Err(..) => panic!()
|
||||
}
|
||||
tx2.send(());
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
|
||||
match UdpSocket::bind(server_ip) {
|
||||
Ok(server) => {
|
||||
let server = box server;
|
||||
let mut stream = server.connect(client_ip);
|
||||
tx1.send(());
|
||||
tx1.send(()).unwrap();
|
||||
let mut buf = [0];
|
||||
match stream.read(&mut buf) {
|
||||
Ok(nread) => {
|
||||
|
|
@ -419,7 +419,7 @@ mod test {
|
|||
}
|
||||
Err(..) => panic!()
|
||||
}
|
||||
rx2.recv();
|
||||
rx2.recv().unwrap();
|
||||
}
|
||||
|
||||
pub fn socket_name(addr: SocketAddr) {
|
||||
|
|
@ -466,14 +466,14 @@ mod test {
|
|||
let (tx2, rx2) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
let mut sock3 = sock3;
|
||||
rx1.recv();
|
||||
rx1.recv().unwrap();
|
||||
sock3.send_to(&[1], addr2).unwrap();
|
||||
tx2.send(());
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
tx1.send(());
|
||||
tx1.send(()).unwrap();
|
||||
let mut buf = [0, 0];
|
||||
assert_eq!(sock1.recv_from(&mut buf), Ok((1, addr2)));
|
||||
rx2.recv();
|
||||
rx2.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -488,9 +488,9 @@ mod test {
|
|||
let _t = Thread::spawn(move|| {
|
||||
let mut sock2 = sock2;
|
||||
sock2.send_to(&[1], addr1).unwrap();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
sock2.send_to(&[2], addr1).unwrap();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
});
|
||||
|
||||
let sock3 = sock1.clone();
|
||||
|
|
@ -500,14 +500,14 @@ mod test {
|
|||
let mut sock3 = sock3;
|
||||
let mut buf = [0, 0];
|
||||
sock3.recv_from(&mut buf).unwrap();
|
||||
tx2.send(());
|
||||
done.send(());
|
||||
tx2.send(()).unwrap();
|
||||
done.send(()).unwrap();
|
||||
});
|
||||
let mut buf = [0, 0];
|
||||
sock1.recv_from(&mut buf).unwrap();
|
||||
tx1.send(());
|
||||
tx1.send(()).unwrap();
|
||||
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -524,12 +524,12 @@ mod test {
|
|||
let mut sock2 = sock2;
|
||||
let mut buf = [0, 1];
|
||||
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
match sock2.recv_from(&mut buf) {
|
||||
Ok(..) => {}
|
||||
Err(e) => panic!("failed receive: {}", e),
|
||||
}
|
||||
serv_tx.send(());
|
||||
serv_tx.send(()).unwrap();
|
||||
});
|
||||
|
||||
let sock3 = sock1.clone();
|
||||
|
|
@ -539,19 +539,19 @@ mod test {
|
|||
let _t = Thread::spawn(move|| {
|
||||
let mut sock3 = sock3;
|
||||
match sock3.send_to(&[1], addr2) {
|
||||
Ok(..) => { let _ = tx2.send_opt(()); }
|
||||
Ok(..) => { let _ = tx2.send(()); }
|
||||
Err(..) => {}
|
||||
}
|
||||
done.send(());
|
||||
done.send(()).unwrap();
|
||||
});
|
||||
match sock1.send_to(&[2], addr2) {
|
||||
Ok(..) => { let _ = tx.send_opt(()); }
|
||||
Ok(..) => { let _ = tx.send(()); }
|
||||
Err(..) => {}
|
||||
}
|
||||
drop(tx);
|
||||
|
||||
rx.recv();
|
||||
serv_rx.recv();
|
||||
rx.recv().unwrap();
|
||||
serv_rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[cfg(not(windows))] // FIXME #17553
|
||||
|
|
@ -568,10 +568,10 @@ mod test {
|
|||
let mut a = a2;
|
||||
assert_eq!(a.recv_from(&mut [0]), Ok((1, addr1)));
|
||||
assert_eq!(a.send_to(&[0], addr1), Ok(()));
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
assert_eq!(a.send_to(&[0], addr1), Ok(()));
|
||||
|
||||
tx2.send(());
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
|
||||
// Make sure that reads time out, but writes can continue
|
||||
|
|
@ -586,11 +586,11 @@ mod test {
|
|||
|
||||
// Clearing the timeout should allow for receiving
|
||||
a.set_timeout(None);
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
assert_eq!(a2.recv_from(&mut [0]), Ok((1, addr2)));
|
||||
|
||||
// Make sure the child didn't die
|
||||
rx2.recv();
|
||||
rx2.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -114,7 +114,7 @@ impl Writer for PipeStream {
|
|||
mod test {
|
||||
use prelude::v1::*;
|
||||
|
||||
use comm::channel;
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
|
||||
#[test]
|
||||
|
|
@ -129,11 +129,11 @@ mod test {
|
|||
let _t = Thread::spawn(move|| {
|
||||
let mut out = out;
|
||||
out.write(&[10]).unwrap();
|
||||
rx.recv(); // don't close the pipe until the other read has finished
|
||||
rx.recv().unwrap(); // don't close the pipe until the other read has finished
|
||||
});
|
||||
|
||||
let mut buf = [0; 10];
|
||||
input.read(&mut buf).unwrap();
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,7 +20,6 @@ use prelude::v1::*;
|
|||
|
||||
use c_str::{CString, ToCStr};
|
||||
use collections::HashMap;
|
||||
use comm::{channel, Receiver};
|
||||
use fmt;
|
||||
use hash::Hash;
|
||||
use io::pipe::{PipeStream, PipePair};
|
||||
|
|
@ -29,6 +28,7 @@ use io;
|
|||
use libc;
|
||||
use os;
|
||||
use path::BytesContainer;
|
||||
use sync::mpsc::{channel, Receiver};
|
||||
use sys::fs::FileDesc;
|
||||
use sys::process::Process as ProcessImp;
|
||||
use sys;
|
||||
|
|
@ -693,10 +693,10 @@ impl Process {
|
|||
Some(stream) => {
|
||||
Thread::spawn(move |:| {
|
||||
let mut stream = stream;
|
||||
tx.send(stream.read_to_end())
|
||||
tx.send(stream.read_to_end()).unwrap();
|
||||
}).detach();
|
||||
}
|
||||
None => tx.send(Ok(Vec::new()))
|
||||
None => tx.send(Ok(Vec::new())).unwrap()
|
||||
}
|
||||
rx
|
||||
}
|
||||
|
|
@ -707,8 +707,8 @@ impl Process {
|
|||
|
||||
Ok(ProcessOutput {
|
||||
status: status,
|
||||
output: stdout.recv().ok().unwrap_or(Vec::new()),
|
||||
error: stderr.recv().ok().unwrap_or(Vec::new()),
|
||||
output: stdout.recv().unwrap().unwrap_or(Vec::new()),
|
||||
error: stderr.recv().unwrap().unwrap_or(Vec::new()),
|
||||
})
|
||||
}
|
||||
|
||||
|
|
@ -743,13 +743,15 @@ impl Drop for Process {
|
|||
mod tests {
|
||||
use prelude::v1::*;
|
||||
|
||||
use comm::channel;
|
||||
use io::fs::PathExtensions;
|
||||
use io::process;
|
||||
use io::timer::*;
|
||||
use io::{Truncate, Write, TimedOut, timer, process, FileNotFound};
|
||||
use io::{Truncate, Write, TimedOut, timer, FileNotFound};
|
||||
use rt::running_on_valgrind;
|
||||
use str;
|
||||
use super::*;
|
||||
use super::{CreatePipe};
|
||||
use super::{InheritFd, Process, PleaseExitSignal, Command, ProcessOutput};
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
use time::Duration;
|
||||
|
||||
|
|
@ -1160,17 +1162,17 @@ mod tests {
|
|||
p.set_timeout(Some(10));
|
||||
assert_eq!(p.wait().err().unwrap().kind, TimedOut);
|
||||
p.signal_kill().unwrap();
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
let _t = Thread::spawn(move|| {
|
||||
let mut p = sleeper();
|
||||
p.set_timeout(Some(10));
|
||||
assert_eq!(p.wait().err().unwrap().kind, TimedOut);
|
||||
p.signal_kill().unwrap();
|
||||
tx2.send(());
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
rx.recv();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -523,7 +523,7 @@ mod tests {
|
|||
use prelude::v1::*;
|
||||
|
||||
use super::*;
|
||||
use comm::channel;
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
|
||||
// FIXME: These functions take Durations but only pass ms to the backend impls.
|
||||
|
||||
use comm::{Receiver, Sender, channel};
|
||||
use sync::mpsc::{Receiver, Sender, channel};
|
||||
use time::Duration;
|
||||
use io::IoResult;
|
||||
use sys::timer::Callback;
|
||||
|
|
@ -40,11 +40,11 @@ use sys::timer::Timer as TimerImp;
|
|||
///
|
||||
/// let timeout = timer.oneshot(Duration::milliseconds(10));
|
||||
/// // do some work
|
||||
/// timeout.recv(); // wait for the timeout to expire
|
||||
/// timeout.recv().unwrap(); // wait for the timeout to expire
|
||||
///
|
||||
/// let periodic = timer.periodic(Duration::milliseconds(10));
|
||||
/// loop {
|
||||
/// periodic.recv();
|
||||
/// periodic.recv().unwrap();
|
||||
/// // this loop is only executed once every 10ms
|
||||
/// }
|
||||
/// # }
|
||||
|
|
@ -126,7 +126,7 @@ impl Timer {
|
|||
/// for _ in range(0u, 100) { /* do work */ }
|
||||
///
|
||||
/// // blocks until 10 ms after the `oneshot` call
|
||||
/// ten_milliseconds.recv();
|
||||
/// ten_milliseconds.recv().unwrap();
|
||||
/// ```
|
||||
///
|
||||
/// ```rust
|
||||
|
|
@ -136,7 +136,7 @@ impl Timer {
|
|||
/// // Incorrect, method chaining-style:
|
||||
/// let mut five_ms = Timer::new().unwrap().oneshot(Duration::milliseconds(5));
|
||||
/// // The timer object was destroyed, so this will always fail:
|
||||
/// // five_ms.recv()
|
||||
/// // five_ms.recv().unwrap()
|
||||
/// ```
|
||||
///
|
||||
/// When provided a zero or negative `duration`, the message will
|
||||
|
|
@ -147,7 +147,7 @@ impl Timer {
|
|||
if in_ms_u64(duration) != 0 {
|
||||
self.inner.oneshot(in_ms_u64(duration), box TimerCallback { tx: tx });
|
||||
} else {
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
}
|
||||
return rx
|
||||
}
|
||||
|
|
@ -178,13 +178,13 @@ impl Timer {
|
|||
/// for _ in range(0u, 100) { /* do work */ }
|
||||
///
|
||||
/// // blocks until 10 ms after the `periodic` call
|
||||
/// ten_milliseconds.recv();
|
||||
/// ten_milliseconds.recv().unwrap();
|
||||
///
|
||||
/// for _ in range(0u, 100) { /* do work */ }
|
||||
///
|
||||
/// // blocks until 20 ms after the `periodic` call (*not* 10ms after the
|
||||
/// // previous `recv`)
|
||||
/// ten_milliseconds.recv();
|
||||
/// ten_milliseconds.recv().unwrap();
|
||||
/// ```
|
||||
///
|
||||
/// ```rust
|
||||
|
|
@ -194,7 +194,7 @@ impl Timer {
|
|||
/// // Incorrect, method chaining-style.
|
||||
/// let mut five_ms = Timer::new().unwrap().periodic(Duration::milliseconds(5));
|
||||
/// // The timer object was destroyed, so this will always fail:
|
||||
/// // five_ms.recv()
|
||||
/// // five_ms.recv().unwrap()
|
||||
/// ```
|
||||
///
|
||||
/// When provided a zero or negative `duration`, the messages will
|
||||
|
|
@ -213,7 +213,7 @@ impl Timer {
|
|||
|
||||
impl Callback for TimerCallback {
|
||||
fn call(&mut self) {
|
||||
let _ = self.tx.send_opt(());
|
||||
let _ = self.tx.send(());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -240,7 +240,7 @@ mod test {
|
|||
#[test]
|
||||
fn test_io_timer_sleep_oneshot() {
|
||||
let mut timer = Timer::new().unwrap();
|
||||
timer.oneshot(Duration::milliseconds(1)).recv();
|
||||
timer.oneshot(Duration::milliseconds(1)).recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -254,8 +254,8 @@ mod test {
|
|||
let mut timer = Timer::new().unwrap();
|
||||
let rx1 = timer.oneshot(Duration::milliseconds(10000));
|
||||
let rx = timer.oneshot(Duration::milliseconds(1));
|
||||
rx.recv();
|
||||
assert_eq!(rx1.recv_opt(), Err(()));
|
||||
rx.recv().unwrap();
|
||||
assert!(rx1.recv().is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -264,16 +264,16 @@ mod test {
|
|||
let rx = timer.oneshot(Duration::milliseconds(100000000));
|
||||
timer.sleep(Duration::milliseconds(1)); // this should invalidate rx
|
||||
|
||||
assert_eq!(rx.recv_opt(), Err(()));
|
||||
assert!(rx.recv().is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_io_timer_sleep_periodic() {
|
||||
let mut timer = Timer::new().unwrap();
|
||||
let rx = timer.periodic(Duration::milliseconds(1));
|
||||
rx.recv();
|
||||
rx.recv();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
rx.recv().unwrap();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -292,12 +292,12 @@ mod test {
|
|||
let mut timer = Timer::new().unwrap();
|
||||
|
||||
let rx = timer.oneshot(Duration::milliseconds(1));
|
||||
rx.recv();
|
||||
assert!(rx.recv_opt().is_err());
|
||||
rx.recv().unwrap();
|
||||
assert!(rx.recv().is_err());
|
||||
|
||||
let rx = timer.oneshot(Duration::milliseconds(1));
|
||||
rx.recv();
|
||||
assert!(rx.recv_opt().is_err());
|
||||
rx.recv().unwrap();
|
||||
assert!(rx.recv().is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -306,20 +306,20 @@ mod test {
|
|||
let orx = timer.oneshot(Duration::milliseconds(100));
|
||||
let prx = timer.periodic(Duration::milliseconds(100));
|
||||
timer.sleep(Duration::milliseconds(1));
|
||||
assert_eq!(orx.recv_opt(), Err(()));
|
||||
assert_eq!(prx.recv_opt(), Err(()));
|
||||
timer.oneshot(Duration::milliseconds(1)).recv();
|
||||
assert!(orx.recv().is_err());
|
||||
assert!(prx.recv().is_err());
|
||||
timer.oneshot(Duration::milliseconds(1)).recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn period() {
|
||||
let mut timer = Timer::new().unwrap();
|
||||
let rx = timer.periodic(Duration::milliseconds(1));
|
||||
rx.recv();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
rx.recv().unwrap();
|
||||
let rx2 = timer.periodic(Duration::milliseconds(1));
|
||||
rx2.recv();
|
||||
rx2.recv();
|
||||
rx2.recv().unwrap();
|
||||
rx2.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -359,7 +359,7 @@ mod test {
|
|||
let timer_rx = timer.periodic(Duration::milliseconds(1000));
|
||||
|
||||
Thread::spawn(move|| {
|
||||
let _ = timer_rx.recv_opt();
|
||||
let _ = timer_rx.recv();
|
||||
}).detach();
|
||||
|
||||
// when we drop the TimerWatcher we're going to destroy the channel,
|
||||
|
|
@ -373,7 +373,7 @@ mod test {
|
|||
let timer_rx = timer.periodic(Duration::milliseconds(1000));
|
||||
|
||||
Thread::spawn(move|| {
|
||||
let _ = timer_rx.recv_opt();
|
||||
let _ = timer_rx.recv();
|
||||
}).detach();
|
||||
|
||||
timer.oneshot(Duration::milliseconds(1));
|
||||
|
|
@ -386,7 +386,7 @@ mod test {
|
|||
let timer_rx = timer.periodic(Duration::milliseconds(1000));
|
||||
|
||||
Thread::spawn(move|| {
|
||||
let _ = timer_rx.recv_opt();
|
||||
let _ = timer_rx.recv();
|
||||
}).detach();
|
||||
|
||||
timer.sleep(Duration::milliseconds(1));
|
||||
|
|
@ -398,7 +398,7 @@ mod test {
|
|||
let mut timer = Timer::new().unwrap();
|
||||
timer.oneshot(Duration::milliseconds(1000))
|
||||
};
|
||||
assert_eq!(rx.recv_opt(), Err(()));
|
||||
assert!(rx.recv().is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -407,7 +407,7 @@ mod test {
|
|||
let mut timer = Timer::new().unwrap();
|
||||
timer.periodic(Duration::milliseconds(1000))
|
||||
};
|
||||
assert_eq!(rx.recv_opt(), Err(()));
|
||||
assert!(rx.recv().is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -446,34 +446,34 @@ mod test {
|
|||
fn oneshot_zero() {
|
||||
let mut timer = Timer::new().unwrap();
|
||||
let rx = timer.oneshot(Duration::milliseconds(0));
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn oneshot_negative() {
|
||||
let mut timer = Timer::new().unwrap();
|
||||
let rx = timer.oneshot(Duration::milliseconds(-1000000));
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn periodic_zero() {
|
||||
let mut timer = Timer::new().unwrap();
|
||||
let rx = timer.periodic(Duration::milliseconds(0));
|
||||
rx.recv();
|
||||
rx.recv();
|
||||
rx.recv();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
rx.recv().unwrap();
|
||||
rx.recv().unwrap();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn periodic_negative() {
|
||||
let mut timer = Timer::new().unwrap();
|
||||
let rx = timer.periodic(Duration::milliseconds(-1000000));
|
||||
rx.recv();
|
||||
rx.recv();
|
||||
rx.recv();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
rx.recv().unwrap();
|
||||
rx.recv().unwrap();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -386,7 +386,7 @@ mod test {
|
|||
let mut r = TeeReader::new(MemReader::new(vec!(0, 1, 2)),
|
||||
Vec::new());
|
||||
assert_eq!(vec!(0, 1, 2), r.read_to_end().unwrap());
|
||||
let (_, w) = r.unwrap();
|
||||
let (_, w) = r.into_inner();
|
||||
assert_eq!(vec!(0, 1, 2), w);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -227,7 +227,6 @@ pub mod hash;
|
|||
pub mod task;
|
||||
pub mod thread;
|
||||
pub mod sync;
|
||||
pub mod comm;
|
||||
|
||||
#[cfg(unix)]
|
||||
#[path = "sys/unix/mod.rs"] mod sys;
|
||||
|
|
@ -255,7 +254,7 @@ mod std {
|
|||
pub use cmp;
|
||||
pub use hash;
|
||||
|
||||
pub use comm; // used for select!()
|
||||
pub use sync; // used for select!()
|
||||
pub use error; // used for try!()
|
||||
pub use fmt; // used for any formatting strings
|
||||
pub use io; // used for println!()
|
||||
|
|
|
|||
|
|
@ -334,7 +334,7 @@ macro_rules! vec {
|
|||
///
|
||||
/// ```
|
||||
/// use std::thread::Thread;
|
||||
/// use std::comm::channel;
|
||||
/// use std::sync::mpsc::channel;
|
||||
///
|
||||
/// let (tx1, rx1) = channel();
|
||||
/// let (tx2, rx2) = channel();
|
||||
|
|
@ -345,21 +345,21 @@ macro_rules! vec {
|
|||
/// Thread::spawn(move|| { tx2.send(calculate_the_answer()) }).detach();
|
||||
///
|
||||
/// select! (
|
||||
/// () = rx1.recv() => println!("the long running task finished first"),
|
||||
/// _ = rx1.recv() => println!("the long running task finished first"),
|
||||
/// answer = rx2.recv() => {
|
||||
/// println!("the answer was: {}", answer);
|
||||
/// println!("the answer was: {}", answer.unwrap());
|
||||
/// }
|
||||
/// )
|
||||
/// ```
|
||||
///
|
||||
/// For more information about select, see the `std::comm::Select` structure.
|
||||
/// For more information about select, see the `std::sync::mpsc::Select` structure.
|
||||
#[macro_export]
|
||||
#[experimental]
|
||||
macro_rules! select {
|
||||
(
|
||||
$($name:pat = $rx:ident.$meth:ident() => $code:expr),+
|
||||
) => ({
|
||||
use std::comm::Select;
|
||||
use std::sync::mpsc::Select;
|
||||
let sel = Select::new();
|
||||
$( let mut $rx = sel.handle(&$rx); )+
|
||||
unsafe {
|
||||
|
|
|
|||
|
|
@ -496,23 +496,25 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn test_real_consts() {
|
||||
let pi: f32 = Float::pi();
|
||||
let two_pi: f32 = Float::two_pi();
|
||||
let frac_pi_2: f32 = Float::frac_pi_2();
|
||||
let frac_pi_3: f32 = Float::frac_pi_3();
|
||||
let frac_pi_4: f32 = Float::frac_pi_4();
|
||||
let frac_pi_6: f32 = Float::frac_pi_6();
|
||||
let frac_pi_8: f32 = Float::frac_pi_8();
|
||||
let frac_1_pi: f32 = Float::frac_1_pi();
|
||||
let frac_2_pi: f32 = Float::frac_2_pi();
|
||||
let frac_2_sqrtpi: f32 = Float::frac_2_sqrtpi();
|
||||
let sqrt2: f32 = Float::sqrt2();
|
||||
let frac_1_sqrt2: f32 = Float::frac_1_sqrt2();
|
||||
let e: f32 = Float::e();
|
||||
let log2_e: f32 = Float::log2_e();
|
||||
let log10_e: f32 = Float::log10_e();
|
||||
let ln_2: f32 = Float::ln_2();
|
||||
let ln_10: f32 = Float::ln_10();
|
||||
use super::consts;
|
||||
|
||||
let pi: f32 = consts::PI;
|
||||
let two_pi: f32 = consts::PI_2;
|
||||
let frac_pi_2: f32 = consts::FRAC_PI_2;
|
||||
let frac_pi_3: f32 = consts::FRAC_PI_3;
|
||||
let frac_pi_4: f32 = consts::FRAC_PI_4;
|
||||
let frac_pi_6: f32 = consts::FRAC_PI_6;
|
||||
let frac_pi_8: f32 = consts::FRAC_PI_8;
|
||||
let frac_1_pi: f32 = consts::FRAC_1_PI;
|
||||
let frac_2_pi: f32 = consts::FRAC_2_PI;
|
||||
let frac_2_sqrtpi: f32 = consts::FRAC_2_SQRTPI;
|
||||
let sqrt2: f32 = consts::SQRT2;
|
||||
let frac_1_sqrt2: f32 = consts::FRAC_1_SQRT2;
|
||||
let e: f32 = consts::E;
|
||||
let log2_e: f32 = consts::LOG2_E;
|
||||
let log10_e: f32 = consts::LOG10_E;
|
||||
let ln_2: f32 = consts::LN_2;
|
||||
let ln_10: f32 = consts::LN_10;
|
||||
|
||||
assert_approx_eq!(two_pi, 2f32 * pi);
|
||||
assert_approx_eq!(frac_pi_2, pi / 2f32);
|
||||
|
|
|
|||
|
|
@ -499,23 +499,24 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn test_real_consts() {
|
||||
let pi: f64 = Float::pi();
|
||||
let two_pi: f64 = Float::two_pi();
|
||||
let frac_pi_2: f64 = Float::frac_pi_2();
|
||||
let frac_pi_3: f64 = Float::frac_pi_3();
|
||||
let frac_pi_4: f64 = Float::frac_pi_4();
|
||||
let frac_pi_6: f64 = Float::frac_pi_6();
|
||||
let frac_pi_8: f64 = Float::frac_pi_8();
|
||||
let frac_1_pi: f64 = Float::frac_1_pi();
|
||||
let frac_2_pi: f64 = Float::frac_2_pi();
|
||||
let frac_2_sqrtpi: f64 = Float::frac_2_sqrtpi();
|
||||
let sqrt2: f64 = Float::sqrt2();
|
||||
let frac_1_sqrt2: f64 = Float::frac_1_sqrt2();
|
||||
let e: f64 = Float::e();
|
||||
let log2_e: f64 = Float::log2_e();
|
||||
let log10_e: f64 = Float::log10_e();
|
||||
let ln_2: f64 = Float::ln_2();
|
||||
let ln_10: f64 = Float::ln_10();
|
||||
use super::consts;
|
||||
let pi: f64 = consts::PI;
|
||||
let two_pi: f64 = consts::PI_2;
|
||||
let frac_pi_2: f64 = consts::FRAC_PI_2;
|
||||
let frac_pi_3: f64 = consts::FRAC_PI_3;
|
||||
let frac_pi_4: f64 = consts::FRAC_PI_4;
|
||||
let frac_pi_6: f64 = consts::FRAC_PI_6;
|
||||
let frac_pi_8: f64 = consts::FRAC_PI_8;
|
||||
let frac_1_pi: f64 = consts::FRAC_1_PI;
|
||||
let frac_2_pi: f64 = consts::FRAC_2_PI;
|
||||
let frac_2_sqrtpi: f64 = consts::FRAC_2_SQRTPI;
|
||||
let sqrt2: f64 = consts::SQRT2;
|
||||
let frac_1_sqrt2: f64 = consts::FRAC_1_SQRT2;
|
||||
let e: f64 = consts::E;
|
||||
let log2_e: f64 = consts::LOG2_E;
|
||||
let log10_e: f64 = consts::LOG10_E;
|
||||
let ln_2: f64 = consts::LN_2;
|
||||
let ln_10: f64 = consts::LN_10;
|
||||
|
||||
assert_approx_eq!(two_pi, 2.0 * pi);
|
||||
assert_approx_eq!(frac_pi_2, pi / 2f64);
|
||||
|
|
|
|||
|
|
@ -1428,7 +1428,8 @@ mod arch_consts {
|
|||
#[cfg(test)]
|
||||
mod tests {
|
||||
use prelude::v1::*;
|
||||
use option;
|
||||
|
||||
use iter::repeat;
|
||||
use os::{env, getcwd, getenv, make_absolute};
|
||||
use os::{split_paths, join_paths, setenv, unsetenv};
|
||||
use os;
|
||||
|
|
@ -1457,7 +1458,7 @@ mod tests {
|
|||
fn test_setenv() {
|
||||
let n = make_rand_name();
|
||||
setenv(n.as_slice(), "VALUE");
|
||||
assert_eq!(getenv(n.as_slice()), option::Option::Some("VALUE".to_string()));
|
||||
assert_eq!(getenv(n.as_slice()), Some("VALUE".to_string()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1465,7 +1466,7 @@ mod tests {
|
|||
let n = make_rand_name();
|
||||
setenv(n.as_slice(), "VALUE");
|
||||
unsetenv(n.as_slice());
|
||||
assert_eq!(getenv(n.as_slice()), option::Option::None);
|
||||
assert_eq!(getenv(n.as_slice()), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1474,9 +1475,9 @@ mod tests {
|
|||
let n = make_rand_name();
|
||||
setenv(n.as_slice(), "1");
|
||||
setenv(n.as_slice(), "2");
|
||||
assert_eq!(getenv(n.as_slice()), option::Option::Some("2".to_string()));
|
||||
assert_eq!(getenv(n.as_slice()), Some("2".to_string()));
|
||||
setenv(n.as_slice(), "");
|
||||
assert_eq!(getenv(n.as_slice()), option::Option::Some("".to_string()));
|
||||
assert_eq!(getenv(n.as_slice()), Some("".to_string()));
|
||||
}
|
||||
|
||||
// Windows GetEnvironmentVariable requires some extra work to make sure
|
||||
|
|
@ -1493,7 +1494,7 @@ mod tests {
|
|||
let n = make_rand_name();
|
||||
setenv(n.as_slice(), s.as_slice());
|
||||
debug!("{}", s.clone());
|
||||
assert_eq!(getenv(n.as_slice()), option::Option::Some(s));
|
||||
assert_eq!(getenv(n.as_slice()), Some(s));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1530,14 +1531,14 @@ mod tests {
|
|||
// MingW seems to set some funky environment variables like
|
||||
// "=C:=C:\MinGW\msys\1.0\bin" and "!::=::\" that are returned
|
||||
// from env() but not visible from getenv().
|
||||
assert!(v2.is_none() || v2 == option::Option::Some(v));
|
||||
assert!(v2.is_none() || v2 == Some(v));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_env_set_get_huge() {
|
||||
let n = make_rand_name();
|
||||
let s = "x".repeat(10000).to_string();
|
||||
let s = repeat("x").take(10000).collect::<String>();
|
||||
setenv(n.as_slice(), s.as_slice());
|
||||
assert_eq!(getenv(n.as_slice()), Some(s));
|
||||
unsetenv(n.as_slice());
|
||||
|
|
@ -1659,8 +1660,8 @@ mod tests {
|
|||
path.push("mmap_file.tmp");
|
||||
let size = MemoryMap::granularity() * 2;
|
||||
let mut file = File::open_mode(&path, Open, ReadWrite).unwrap();
|
||||
file.seek(size as i64, SeekSet);
|
||||
file.write_u8(0);
|
||||
file.seek(size as i64, SeekSet).unwrap();
|
||||
file.write_u8(0).unwrap();
|
||||
|
||||
let chunk = MemoryMap::new(size / 2, &[
|
||||
MapOption::MapReadable,
|
||||
|
|
|
|||
|
|
@ -1119,9 +1119,13 @@ fn prefix_len(p: Option<PathPrefix>) -> uint {
|
|||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use prelude::v1::Option::{mod, Some, None};
|
||||
use prelude::v1::{Vec, Clone, AsSlice, SliceExt, CloneSliceExt, IteratorExt};
|
||||
use prelude::v1::{DoubleEndedIteratorExt, Str, ToString, GenericPath};
|
||||
|
||||
use super::PathPrefix::*;
|
||||
use super::parse_prefix;
|
||||
use super::*;
|
||||
|
||||
use clone::Clone;
|
||||
use iter::{IteratorExt, DoubleEndedIteratorExt};
|
||||
|
|
|
|||
|
|
@ -340,7 +340,7 @@ mod imp {
|
|||
mod test {
|
||||
use prelude::v1::*;
|
||||
|
||||
use comm::channel;
|
||||
use sync::mpsc::channel;
|
||||
use rand::Rng;
|
||||
use super::OsRng;
|
||||
use thread::Thread;
|
||||
|
|
@ -366,7 +366,7 @@ mod test {
|
|||
|
||||
Thread::spawn(move|| {
|
||||
// wait until all the tasks are ready to go.
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
|
||||
// deschedule to attempt to interleave things as much
|
||||
// as possible (XXX: is this a good test?)
|
||||
|
|
@ -387,7 +387,7 @@ mod test {
|
|||
|
||||
// start all the tasks
|
||||
for tx in txs.iter() {
|
||||
tx.send(())
|
||||
tx.send(()).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ mod tests {
|
|||
use prelude::v1::*;
|
||||
|
||||
use sync::{Arc, Barrier};
|
||||
use comm::{channel, Empty};
|
||||
use sync::mpsc::{channel, TryRecvError};
|
||||
use thread::Thread;
|
||||
|
||||
#[test]
|
||||
|
|
@ -105,21 +105,21 @@ mod tests {
|
|||
let tx = tx.clone();
|
||||
Thread::spawn(move|| {
|
||||
c.wait();
|
||||
tx.send(true);
|
||||
tx.send(true).unwrap();
|
||||
}).detach();
|
||||
}
|
||||
|
||||
// At this point, all spawned tasks should be blocked,
|
||||
// so we shouldn't get anything from the port
|
||||
assert!(match rx.try_recv() {
|
||||
Err(Empty) => true,
|
||||
Err(TryRecvError::Empty) => true,
|
||||
_ => false,
|
||||
});
|
||||
|
||||
barrier.wait();
|
||||
// Now, the barrier is cleared and we should get data.
|
||||
for _ in range(0u, 9) {
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -281,8 +281,8 @@ impl StaticCondvar {
|
|||
mod tests {
|
||||
use prelude::v1::*;
|
||||
|
||||
use comm::channel;
|
||||
use super::{StaticCondvar, CONDVAR_INIT};
|
||||
use sync::mpsc::channel;
|
||||
use sync::{StaticMutex, MUTEX_INIT, Condvar, Mutex, Arc};
|
||||
use thread::Thread;
|
||||
use time::Duration;
|
||||
|
|
@ -331,25 +331,25 @@ mod tests {
|
|||
let mut cnt = lock.lock().unwrap();
|
||||
*cnt += 1;
|
||||
if *cnt == N {
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
}
|
||||
while *cnt != 0 {
|
||||
cnt = cond.wait(cnt).unwrap();
|
||||
}
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
}).detach();
|
||||
}
|
||||
drop(tx);
|
||||
|
||||
let &(ref lock, ref cond) = &*data;
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
let mut cnt = lock.lock().unwrap();
|
||||
*cnt = 0;
|
||||
cond.notify_all();
|
||||
drop(cnt);
|
||||
|
||||
for _ in range(0, N) {
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ use core::prelude::*;
|
|||
use core::mem::replace;
|
||||
|
||||
use self::FutureState::*;
|
||||
use comm::{Receiver, channel};
|
||||
use sync::mpsc::{Receiver, channel};
|
||||
use thunk::{Thunk};
|
||||
use thread::Thread;
|
||||
|
||||
|
|
@ -122,8 +122,8 @@ impl<A:Send> Future<A> {
|
|||
* waiting for the result to be received on the port.
|
||||
*/
|
||||
|
||||
Future::from_fn(move|:| {
|
||||
rx.recv()
|
||||
Future::from_fn(move |:| {
|
||||
rx.recv().unwrap()
|
||||
})
|
||||
}
|
||||
|
||||
|
|
@ -141,7 +141,7 @@ impl<A:Send> Future<A> {
|
|||
|
||||
Thread::spawn(move |:| {
|
||||
// Don't panic if the other end has hung up
|
||||
let _ = tx.send_opt(blk());
|
||||
let _ = tx.send(blk());
|
||||
}).detach();
|
||||
|
||||
Future::from_receiver(rx)
|
||||
|
|
@ -151,7 +151,7 @@ impl<A:Send> Future<A> {
|
|||
#[cfg(test)]
|
||||
mod test {
|
||||
use prelude::v1::*;
|
||||
use comm::channel;
|
||||
use sync::mpsc::channel;
|
||||
use sync::Future;
|
||||
use thread::Thread;
|
||||
|
||||
|
|
@ -164,7 +164,7 @@ mod test {
|
|||
#[test]
|
||||
fn test_from_receiver() {
|
||||
let (tx, rx) = channel();
|
||||
tx.send("whale".to_string());
|
||||
tx.send("whale".to_string()).unwrap();
|
||||
let mut f = Future::from_receiver(rx);
|
||||
assert_eq!(f.get(), "whale");
|
||||
}
|
||||
|
|
@ -184,7 +184,7 @@ mod test {
|
|||
#[test]
|
||||
fn test_interface_unwrap() {
|
||||
let f = Future::from_value("fail".to_string());
|
||||
assert_eq!(f.unwrap(), "fail");
|
||||
assert_eq!(f.into_inner(), "fail");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -213,8 +213,8 @@ mod test {
|
|||
let f = Future::spawn(move|| { expected });
|
||||
let _t = Thread::spawn(move|| {
|
||||
let mut f = f;
|
||||
tx.send(f.get());
|
||||
tx.send(f.get()).unwrap();
|
||||
});
|
||||
assert_eq!(rx.recv(), expected);
|
||||
assert_eq!(rx.recv().unwrap(), expected);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,6 +33,8 @@ pub use self::future::Future;
|
|||
pub use self::task_pool::TaskPool;
|
||||
|
||||
pub mod atomic;
|
||||
pub mod mpsc;
|
||||
|
||||
mod barrier;
|
||||
mod condvar;
|
||||
mod future;
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -155,7 +155,7 @@ impl<T: Send> Drop for Queue<T> {
|
|||
mod tests {
|
||||
use prelude::v1::*;
|
||||
|
||||
use comm::channel;
|
||||
use sync::mpsc::channel;
|
||||
use super::{Queue, Data, Empty, Inconsistent};
|
||||
use sync::Arc;
|
||||
use thread::Thread;
|
||||
|
|
@ -186,7 +186,7 @@ mod tests {
|
|||
for i in range(0, nmsgs) {
|
||||
q.push(i);
|
||||
}
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
}).detach();
|
||||
}
|
||||
|
||||
|
|
@ -199,7 +199,7 @@ mod tests {
|
|||
}
|
||||
drop(tx);
|
||||
for _ in range(0, nthreads) {
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -39,8 +39,8 @@ use self::MyUpgrade::*;
|
|||
|
||||
use core::prelude::*;
|
||||
|
||||
use comm::Receiver;
|
||||
use comm::blocking::{mod, SignalToken};
|
||||
use sync::mpsc::Receiver;
|
||||
use sync::mpsc::blocking::{mod, SignalToken};
|
||||
use core::mem;
|
||||
use sync::atomic;
|
||||
|
||||
|
|
@ -27,20 +27,20 @@
|
|||
//! # Example
|
||||
//!
|
||||
//! ```rust
|
||||
//! use std::comm::channel;
|
||||
//! use std::sync::mpsc::channel;
|
||||
//!
|
||||
//! let (tx1, rx1) = channel();
|
||||
//! let (tx2, rx2) = channel();
|
||||
//!
|
||||
//! tx1.send(1i);
|
||||
//! tx2.send(2i);
|
||||
//! tx1.send(1i).unwrap();
|
||||
//! tx2.send(2i).unwrap();
|
||||
//!
|
||||
//! select! {
|
||||
//! val = rx1.recv() => {
|
||||
//! assert_eq!(val, 1i);
|
||||
//! assert_eq!(val.unwrap(), 1i);
|
||||
//! },
|
||||
//! val = rx2.recv() => {
|
||||
//! assert_eq!(val, 2i);
|
||||
//! assert_eq!(val.unwrap(), 2i);
|
||||
//! }
|
||||
//! }
|
||||
//! ```
|
||||
|
|
@ -61,8 +61,8 @@ use core::kinds::marker;
|
|||
use core::mem;
|
||||
use core::uint;
|
||||
|
||||
use comm::Receiver;
|
||||
use comm::blocking::{mod, SignalToken};
|
||||
use sync::mpsc::{Receiver, RecvError};
|
||||
use sync::mpsc::blocking::{mod, SignalToken};
|
||||
|
||||
/// The "receiver set" of the select interface. This structure is used to manage
|
||||
/// a set of receivers which are being selected over.
|
||||
|
|
@ -247,13 +247,10 @@ impl<'rx, T: Send> Handle<'rx, T> {
|
|||
#[inline]
|
||||
pub fn id(&self) -> uint { self.id }
|
||||
|
||||
/// Receive a value on the underlying receiver. Has the same semantics as
|
||||
/// `Receiver.recv`
|
||||
pub fn recv(&mut self) -> T { self.rx.recv() }
|
||||
/// Block to receive a value on the underlying receiver, returning `Some` on
|
||||
/// success or `None` if the channel disconnects. This function has the same
|
||||
/// semantics as `Receiver.recv_opt`
|
||||
pub fn recv_opt(&mut self) -> Result<T, ()> { self.rx.recv_opt() }
|
||||
/// semantics as `Receiver.recv`
|
||||
pub fn recv(&mut self) -> Result<T, RecvError> { self.rx.recv() }
|
||||
|
||||
/// Adds this handle to the receiver set that the handle was created from. This
|
||||
/// method can be called multiple times, but it has no effect if `add` was
|
||||
|
|
@ -339,8 +336,9 @@ impl Iterator<*mut Handle<'static, ()>> for Packets {
|
|||
mod test {
|
||||
use prelude::v1::*;
|
||||
|
||||
use comm::*;
|
||||
use thread::Thread;
|
||||
use super::*;
|
||||
use sync::mpsc::*;
|
||||
|
||||
// Don't use the libstd version so we can pull in the right Select structure
|
||||
// (std::comm points at the wrong one)
|
||||
|
|
@ -348,7 +346,6 @@ mod test {
|
|||
(
|
||||
$($name:pat = $rx:ident.$meth:ident() => $code:expr),+
|
||||
) => ({
|
||||
use comm::Select;
|
||||
let sel = Select::new();
|
||||
$( let mut $rx = sel.handle(&$rx); )+
|
||||
unsafe {
|
||||
|
|
@ -364,24 +361,24 @@ mod test {
|
|||
fn smoke() {
|
||||
let (tx1, rx1) = channel::<int>();
|
||||
let (tx2, rx2) = channel::<int>();
|
||||
tx1.send(1);
|
||||
tx1.send(1).unwrap();
|
||||
select! {
|
||||
foo = rx1.recv() => { assert_eq!(foo, 1); },
|
||||
foo = rx1.recv() => { assert_eq!(foo.unwrap(), 1); },
|
||||
_bar = rx2.recv() => { panic!() }
|
||||
}
|
||||
tx2.send(2);
|
||||
tx2.send(2).unwrap();
|
||||
select! {
|
||||
_foo = rx1.recv() => { panic!() },
|
||||
bar = rx2.recv() => { assert_eq!(bar, 2) }
|
||||
bar = rx2.recv() => { assert_eq!(bar.unwrap(), 2) }
|
||||
}
|
||||
drop(tx1);
|
||||
select! {
|
||||
foo = rx1.recv_opt() => { assert_eq!(foo, Err(())); },
|
||||
foo = rx1.recv() => { assert!(foo.is_err()); },
|
||||
_bar = rx2.recv() => { panic!() }
|
||||
}
|
||||
drop(tx2);
|
||||
select! {
|
||||
bar = rx2.recv_opt() => { assert_eq!(bar, Err(())); }
|
||||
bar = rx2.recv() => { assert!(bar.is_err()); }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -392,13 +389,13 @@ mod test {
|
|||
let (_tx3, rx3) = channel::<int>();
|
||||
let (_tx4, rx4) = channel::<int>();
|
||||
let (tx5, rx5) = channel::<int>();
|
||||
tx5.send(4);
|
||||
tx5.send(4).unwrap();
|
||||
select! {
|
||||
_foo = rx1.recv() => { panic!("1") },
|
||||
_foo = rx2.recv() => { panic!("2") },
|
||||
_foo = rx3.recv() => { panic!("3") },
|
||||
_foo = rx4.recv() => { panic!("4") },
|
||||
foo = rx5.recv() => { assert_eq!(foo, 4); }
|
||||
foo = rx5.recv() => { assert_eq!(foo.unwrap(), 4); }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -409,8 +406,8 @@ mod test {
|
|||
drop(tx2);
|
||||
|
||||
select! {
|
||||
_a1 = rx1.recv_opt() => { panic!() },
|
||||
a2 = rx2.recv_opt() => { assert_eq!(a2, Err(())); }
|
||||
_a1 = rx1.recv() => { panic!() },
|
||||
a2 = rx2.recv() => { assert!(a2.is_err()); }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -422,18 +419,18 @@ mod test {
|
|||
|
||||
let _t = Thread::spawn(move|| {
|
||||
for _ in range(0u, 20) { Thread::yield_now(); }
|
||||
tx1.send(1);
|
||||
rx3.recv();
|
||||
tx1.send(1).unwrap();
|
||||
rx3.recv().unwrap();
|
||||
for _ in range(0u, 20) { Thread::yield_now(); }
|
||||
});
|
||||
|
||||
select! {
|
||||
a = rx1.recv() => { assert_eq!(a, 1); },
|
||||
a = rx1.recv() => { assert_eq!(a.unwrap(), 1); },
|
||||
_b = rx2.recv() => { panic!() }
|
||||
}
|
||||
tx3.send(1);
|
||||
tx3.send(1).unwrap();
|
||||
select! {
|
||||
a = rx1.recv_opt() => { assert_eq!(a, Err(())); },
|
||||
a = rx1.recv() => { assert!(a.is_err()) },
|
||||
_b = rx2.recv() => { panic!() }
|
||||
}
|
||||
}
|
||||
|
|
@ -446,22 +443,22 @@ mod test {
|
|||
|
||||
let _t = Thread::spawn(move|| {
|
||||
for _ in range(0u, 20) { Thread::yield_now(); }
|
||||
tx1.send(1);
|
||||
tx2.send(2);
|
||||
rx3.recv();
|
||||
tx1.send(1).unwrap();
|
||||
tx2.send(2).unwrap();
|
||||
rx3.recv().unwrap();
|
||||
});
|
||||
|
||||
select! {
|
||||
a = rx1.recv() => { assert_eq!(a, 1); },
|
||||
a = rx2.recv() => { assert_eq!(a, 2); }
|
||||
a = rx1.recv() => { assert_eq!(a.unwrap(), 1); },
|
||||
a = rx2.recv() => { assert_eq!(a.unwrap(), 2); }
|
||||
}
|
||||
select! {
|
||||
a = rx1.recv() => { assert_eq!(a, 1); },
|
||||
a = rx2.recv() => { assert_eq!(a, 2); }
|
||||
a = rx1.recv() => { assert_eq!(a.unwrap(), 1); },
|
||||
a = rx2.recv() => { assert_eq!(a.unwrap(), 2); }
|
||||
}
|
||||
assert_eq!(rx1.try_recv(), Err(Empty));
|
||||
assert_eq!(rx2.try_recv(), Err(Empty));
|
||||
tx3.send(());
|
||||
assert_eq!(rx1.try_recv(), Err(TryRecvError::Empty));
|
||||
assert_eq!(rx2.try_recv(), Err(TryRecvError::Empty));
|
||||
tx3.send(()).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -474,20 +471,20 @@ mod test {
|
|||
let _t = Thread::spawn(move|| {
|
||||
for i in range(0, AMT) {
|
||||
if i % 2 == 0 {
|
||||
tx1.send(i);
|
||||
tx1.send(i).unwrap();
|
||||
} else {
|
||||
tx2.send(i);
|
||||
tx2.send(i).unwrap();
|
||||
}
|
||||
rx3.recv();
|
||||
rx3.recv().unwrap();
|
||||
}
|
||||
});
|
||||
|
||||
for i in range(0, AMT) {
|
||||
select! {
|
||||
i1 = rx1.recv() => { assert!(i % 2 == 0 && i == i1); },
|
||||
i2 = rx2.recv() => { assert!(i % 2 == 1 && i == i2); }
|
||||
i1 = rx1.recv() => { assert!(i % 2 == 0 && i == i1.unwrap()); },
|
||||
i2 = rx2.recv() => { assert!(i % 2 == 1 && i == i2.unwrap()); }
|
||||
}
|
||||
tx3.send(());
|
||||
tx3.send(()).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -498,19 +495,19 @@ mod test {
|
|||
let (tx3, rx3) = channel::<()>();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
rx3.recv();
|
||||
rx3.recv().unwrap();
|
||||
tx1.clone();
|
||||
assert_eq!(rx3.try_recv(), Err(Empty));
|
||||
tx1.send(2);
|
||||
rx3.recv();
|
||||
assert_eq!(rx3.try_recv(), Err(TryRecvError::Empty));
|
||||
tx1.send(2).unwrap();
|
||||
rx3.recv().unwrap();
|
||||
});
|
||||
|
||||
tx3.send(());
|
||||
tx3.send(()).unwrap();
|
||||
select! {
|
||||
_i1 = rx1.recv() => {},
|
||||
_i2 = rx2.recv() => panic!()
|
||||
}
|
||||
tx3.send(());
|
||||
tx3.send(()).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -520,19 +517,19 @@ mod test {
|
|||
let (tx3, rx3) = channel::<()>();
|
||||
|
||||
let _t = Thread::spawn(move|| {
|
||||
rx3.recv();
|
||||
rx3.recv().unwrap();
|
||||
tx1.clone();
|
||||
assert_eq!(rx3.try_recv(), Err(Empty));
|
||||
tx1.send(2);
|
||||
rx3.recv();
|
||||
assert_eq!(rx3.try_recv(), Err(TryRecvError::Empty));
|
||||
tx1.send(2).unwrap();
|
||||
rx3.recv().unwrap();
|
||||
});
|
||||
|
||||
tx3.send(());
|
||||
tx3.send(()).unwrap();
|
||||
select! {
|
||||
_i1 = rx1.recv() => {},
|
||||
_i2 = rx2.recv() => panic!()
|
||||
}
|
||||
tx3.send(());
|
||||
tx3.send(()).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -547,31 +544,31 @@ mod test {
|
|||
unsafe { h2.add(); }
|
||||
unsafe { h1.add(); }
|
||||
assert_eq!(s.wait(), h2.id);
|
||||
tx3.send(());
|
||||
tx3.send(()).unwrap();
|
||||
});
|
||||
|
||||
for _ in range(0u, 1000) { Thread::yield_now(); }
|
||||
drop(tx1.clone());
|
||||
tx2.send(());
|
||||
rx3.recv();
|
||||
tx2.send(()).unwrap();
|
||||
rx3.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn preflight1() {
|
||||
let (tx, rx) = channel();
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
select! {
|
||||
() = rx.recv() => {}
|
||||
_n = rx.recv() => {}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn preflight2() {
|
||||
let (tx, rx) = channel();
|
||||
tx.send(());
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
tx.send(()).unwrap();
|
||||
select! {
|
||||
() = rx.recv() => {}
|
||||
_n = rx.recv() => {}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -579,16 +576,16 @@ mod test {
|
|||
fn preflight3() {
|
||||
let (tx, rx) = channel();
|
||||
drop(tx.clone());
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
select! {
|
||||
() = rx.recv() => {}
|
||||
_n = rx.recv() => {}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn preflight4() {
|
||||
let (tx, rx) = channel();
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
let s = Select::new();
|
||||
let mut h = s.handle(&rx);
|
||||
unsafe { h.add(); }
|
||||
|
|
@ -598,8 +595,8 @@ mod test {
|
|||
#[test]
|
||||
fn preflight5() {
|
||||
let (tx, rx) = channel();
|
||||
tx.send(());
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
tx.send(()).unwrap();
|
||||
let s = Select::new();
|
||||
let mut h = s.handle(&rx);
|
||||
unsafe { h.add(); }
|
||||
|
|
@ -610,7 +607,7 @@ mod test {
|
|||
fn preflight6() {
|
||||
let (tx, rx) = channel();
|
||||
drop(tx.clone());
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
let s = Select::new();
|
||||
let mut h = s.handle(&rx);
|
||||
unsafe { h.add(); }
|
||||
|
|
@ -630,9 +627,9 @@ mod test {
|
|||
#[test]
|
||||
fn preflight8() {
|
||||
let (tx, rx) = channel();
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
drop(tx);
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
let s = Select::new();
|
||||
let mut h = s.handle(&rx);
|
||||
unsafe { h.add(); }
|
||||
|
|
@ -643,9 +640,9 @@ mod test {
|
|||
fn preflight9() {
|
||||
let (tx, rx) = channel();
|
||||
drop(tx.clone());
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
drop(tx);
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
let s = Select::new();
|
||||
let mut h = s.handle(&rx);
|
||||
unsafe { h.add(); }
|
||||
|
|
@ -658,34 +655,34 @@ mod test {
|
|||
let (tx2, rx2) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
select! {
|
||||
() = rx1.recv() => {}
|
||||
_n = rx1.recv() => {}
|
||||
}
|
||||
tx2.send(());
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
|
||||
for _ in range(0u, 100) { Thread::yield_now() }
|
||||
tx1.send(());
|
||||
rx2.recv();
|
||||
tx1.send(()).unwrap();
|
||||
rx2.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stream_data_waiting() {
|
||||
let (tx1, rx1) = channel();
|
||||
let (tx2, rx2) = channel();
|
||||
tx1.send(());
|
||||
tx1.send(());
|
||||
rx1.recv();
|
||||
rx1.recv();
|
||||
tx1.send(()).unwrap();
|
||||
tx1.send(()).unwrap();
|
||||
rx1.recv().unwrap();
|
||||
rx1.recv().unwrap();
|
||||
let _t = Thread::spawn(move|| {
|
||||
select! {
|
||||
() = rx1.recv() => {}
|
||||
_n = rx1.recv() => {}
|
||||
}
|
||||
tx2.send(());
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
|
||||
for _ in range(0u, 100) { Thread::yield_now() }
|
||||
tx1.send(());
|
||||
rx2.recv();
|
||||
tx1.send(()).unwrap();
|
||||
rx2.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -693,26 +690,26 @@ mod test {
|
|||
let (tx1, rx1) = channel();
|
||||
let (tx2, rx2) = channel();
|
||||
drop(tx1.clone());
|
||||
tx1.send(());
|
||||
rx1.recv();
|
||||
tx1.send(()).unwrap();
|
||||
rx1.recv().unwrap();
|
||||
let _t = Thread::spawn(move|| {
|
||||
select! {
|
||||
() = rx1.recv() => {}
|
||||
_n = rx1.recv() => {}
|
||||
}
|
||||
tx2.send(());
|
||||
tx2.send(()).unwrap();
|
||||
});
|
||||
|
||||
for _ in range(0u, 100) { Thread::yield_now() }
|
||||
tx1.send(());
|
||||
rx2.recv();
|
||||
tx1.send(()).unwrap();
|
||||
rx2.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sync1() {
|
||||
let (tx, rx) = sync_channel::<int>(1);
|
||||
tx.send(1);
|
||||
tx.send(1).unwrap();
|
||||
select! {
|
||||
n = rx.recv() => { assert_eq!(n, 1); }
|
||||
n = rx.recv() => { assert_eq!(n.unwrap(), 1); }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -721,10 +718,10 @@ mod test {
|
|||
let (tx, rx) = sync_channel::<int>(0);
|
||||
let _t = Thread::spawn(move|| {
|
||||
for _ in range(0u, 100) { Thread::yield_now() }
|
||||
tx.send(1);
|
||||
tx.send(1).unwrap();
|
||||
});
|
||||
select! {
|
||||
n = rx.recv() => { assert_eq!(n, 1); }
|
||||
n = rx.recv() => { assert_eq!(n.unwrap(), 1); }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -732,16 +729,18 @@ mod test {
|
|||
fn sync3() {
|
||||
let (tx1, rx1) = sync_channel::<int>(0);
|
||||
let (tx2, rx2): (Sender<int>, Receiver<int>) = channel();
|
||||
let _t = Thread::spawn(move|| { tx1.send(1); });
|
||||
let _t = Thread::spawn(move|| { tx2.send(2); });
|
||||
let _t = Thread::spawn(move|| { tx1.send(1).unwrap(); });
|
||||
let _t = Thread::spawn(move|| { tx2.send(2).unwrap(); });
|
||||
select! {
|
||||
n = rx1.recv() => {
|
||||
let n = n.unwrap();
|
||||
assert_eq!(n, 1);
|
||||
assert_eq!(rx2.recv(), 2);
|
||||
assert_eq!(rx2.recv().unwrap(), 2);
|
||||
},
|
||||
n = rx2.recv() => {
|
||||
let n = n.unwrap();
|
||||
assert_eq!(n, 2);
|
||||
assert_eq!(rx1.recv(), 1);
|
||||
assert_eq!(rx1.recv().unwrap(), 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -26,10 +26,10 @@ use core::cmp;
|
|||
use core::int;
|
||||
|
||||
use sync::{atomic, Mutex, MutexGuard};
|
||||
use comm::mpsc_queue as mpsc;
|
||||
use comm::blocking::{mod, SignalToken};
|
||||
use comm::select::StartResult;
|
||||
use comm::select::StartResult::*;
|
||||
use sync::mpsc::mpsc_queue as mpsc;
|
||||
use sync::mpsc::blocking::{mod, SignalToken};
|
||||
use sync::mpsc::select::StartResult;
|
||||
use sync::mpsc::select::StartResult::*;
|
||||
use thread::Thread;
|
||||
|
||||
const DISCONNECTED: int = int::MIN;
|
||||
|
|
@ -245,7 +245,7 @@ mod test {
|
|||
use sync::Arc;
|
||||
use super::Queue;
|
||||
use thread::Thread;
|
||||
use comm::channel;
|
||||
use sync::mpsc::channel;
|
||||
|
||||
#[test]
|
||||
fn smoke() {
|
||||
|
|
@ -332,12 +332,12 @@ mod test {
|
|||
}
|
||||
}
|
||||
}
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
for _ in range(0i, 100000) {
|
||||
q.push(1);
|
||||
}
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -28,10 +28,10 @@ use core::cmp;
|
|||
use core::int;
|
||||
use thread::Thread;
|
||||
|
||||
use sync::mpsc::blocking::{mod, SignalToken};
|
||||
use sync::mpsc::spsc_queue as spsc;
|
||||
use sync::mpsc::Receiver;
|
||||
use sync::atomic;
|
||||
use comm::spsc_queue as spsc;
|
||||
use comm::Receiver;
|
||||
use comm::blocking::{mod, SignalToken};
|
||||
|
||||
const DISCONNECTED: int = int::MIN;
|
||||
#[cfg(test)]
|
||||
|
|
@ -42,8 +42,8 @@ use vec::Vec;
|
|||
use core::mem;
|
||||
|
||||
use sync::{atomic, Mutex, MutexGuard};
|
||||
use comm::blocking::{mod, WaitToken, SignalToken};
|
||||
use comm::select::StartResult::{mod, Installed, Abort};
|
||||
use sync::mpsc::blocking::{mod, WaitToken, SignalToken};
|
||||
use sync::mpsc::select::StartResult::{mod, Installed, Abort};
|
||||
|
||||
pub struct Packet<T> {
|
||||
/// Only field outside of the mutex. Just done for kicks, but mainly because
|
||||
|
|
@ -204,14 +204,14 @@ impl<T: Send> Packet<T> {
|
|||
pub fn try_send(&self, t: T) -> Result<(), super::TrySendError<T>> {
|
||||
let mut guard = self.lock.lock().unwrap();
|
||||
if guard.disconnected {
|
||||
Err(super::RecvDisconnected(t))
|
||||
Err(super::TrySendError::Disconnected(t))
|
||||
} else if guard.buf.size() == guard.buf.cap() {
|
||||
Err(super::Full(t))
|
||||
Err(super::TrySendError::Full(t))
|
||||
} else if guard.cap == 0 {
|
||||
// With capacity 0, even though we have buffer space we can't
|
||||
// transfer the data unless there's a receiver waiting.
|
||||
match mem::replace(&mut guard.blocker, NoneBlocked) {
|
||||
NoneBlocked => Err(super::Full(t)),
|
||||
NoneBlocked => Err(super::TrySendError::Full(t)),
|
||||
BlockedSender(..) => unreachable!(),
|
||||
BlockedReceiver(token) => {
|
||||
guard.buf.enqueue(t);
|
||||
|
|
@ -48,7 +48,7 @@ use sys_common::mutex as sys;
|
|||
/// ```rust
|
||||
/// use std::sync::{Arc, Mutex};
|
||||
/// use std::thread::Thread;
|
||||
/// use std::comm::channel;
|
||||
/// use std::sync::mpsc::channel;
|
||||
///
|
||||
/// const N: uint = 10;
|
||||
///
|
||||
|
|
@ -72,13 +72,13 @@ use sys_common::mutex as sys;
|
|||
/// let mut data = data.lock().unwrap();
|
||||
/// *data += 1;
|
||||
/// if *data == N {
|
||||
/// tx.send(());
|
||||
/// tx.send(()).unwrap();
|
||||
/// }
|
||||
/// // the lock is unlocked here when `data` goes out of scope.
|
||||
/// }).detach();
|
||||
/// }
|
||||
///
|
||||
/// rx.recv();
|
||||
/// rx.recv().unwrap();
|
||||
/// ```
|
||||
///
|
||||
/// To recover from a poisoned mutex:
|
||||
|
|
@ -325,7 +325,7 @@ pub fn guard_poison<'a, T>(guard: &MutexGuard<'a, T>) -> &'a poison::Flag {
|
|||
mod test {
|
||||
use prelude::v1::*;
|
||||
|
||||
use comm::channel;
|
||||
use sync::mpsc::channel;
|
||||
use sync::{Arc, Mutex, StaticMutex, MUTEX_INIT, Condvar};
|
||||
use thread::Thread;
|
||||
|
||||
|
|
@ -370,14 +370,14 @@ mod test {
|
|||
let (tx, rx) = channel();
|
||||
for _ in range(0, K) {
|
||||
let tx2 = tx.clone();
|
||||
Thread::spawn(move|| { inc(); tx2.send(()); }).detach();
|
||||
Thread::spawn(move|| { inc(); tx2.send(()).unwrap(); }).detach();
|
||||
let tx2 = tx.clone();
|
||||
Thread::spawn(move|| { inc(); tx2.send(()); }).detach();
|
||||
Thread::spawn(move|| { inc(); tx2.send(()).unwrap(); }).detach();
|
||||
}
|
||||
|
||||
drop(tx);
|
||||
for _ in range(0, 2 * K) {
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
assert_eq!(unsafe {CNT}, J * K * 2);
|
||||
unsafe {
|
||||
|
|
@ -398,7 +398,7 @@ mod test {
|
|||
let (tx, rx) = channel();
|
||||
let _t = Thread::spawn(move|| {
|
||||
// wait until parent gets in
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
let &(ref lock, ref cvar) = &*packet2.0;
|
||||
let mut lock = lock.lock().unwrap();
|
||||
*lock = true;
|
||||
|
|
@ -407,7 +407,7 @@ mod test {
|
|||
|
||||
let &(ref lock, ref cvar) = &*packet.0;
|
||||
let mut lock = lock.lock().unwrap();
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
assert!(!*lock);
|
||||
while !*lock {
|
||||
lock = cvar.wait(lock).unwrap();
|
||||
|
|
@ -421,7 +421,7 @@ mod test {
|
|||
let (tx, rx) = channel();
|
||||
|
||||
let _t = Thread::spawn(move || -> () {
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
let &(ref lock, ref cvar) = &*packet2.0;
|
||||
let _g = lock.lock().unwrap();
|
||||
cvar.notify_one();
|
||||
|
|
@ -431,7 +431,7 @@ mod test {
|
|||
|
||||
let &(ref lock, ref cvar) = &*packet.0;
|
||||
let mut lock = lock.lock().unwrap();
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
while *lock == 1 {
|
||||
match cvar.wait(lock) {
|
||||
Ok(l) => {
|
||||
|
|
@ -465,9 +465,9 @@ mod test {
|
|||
let lock = arc2.lock().unwrap();
|
||||
let lock2 = lock.lock().unwrap();
|
||||
assert_eq!(*lock2, 1);
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -126,7 +126,7 @@ mod test {
|
|||
|
||||
use thread::Thread;
|
||||
use super::{ONCE_INIT, Once};
|
||||
use comm::channel;
|
||||
use sync::mpsc::channel;
|
||||
|
||||
#[test]
|
||||
fn smoke_once() {
|
||||
|
|
@ -155,7 +155,7 @@ mod test {
|
|||
});
|
||||
assert!(run);
|
||||
}
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
}).detach();
|
||||
}
|
||||
|
||||
|
|
@ -168,7 +168,7 @@ mod test {
|
|||
}
|
||||
|
||||
for _ in range(0u, 10) {
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -359,7 +359,7 @@ mod tests {
|
|||
use prelude::v1::*;
|
||||
|
||||
use rand::{mod, Rng};
|
||||
use comm::channel;
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
use sync::{Arc, RWLock, StaticRWLock, RWLOCK_INIT};
|
||||
|
||||
|
|
@ -404,7 +404,7 @@ mod tests {
|
|||
}).detach();
|
||||
}
|
||||
drop(tx);
|
||||
let _ = rx.recv_opt();
|
||||
let _ = rx.recv();
|
||||
unsafe { R.destroy(); }
|
||||
}
|
||||
|
||||
|
|
@ -467,7 +467,7 @@ mod tests {
|
|||
Thread::yield_now();
|
||||
*lock = tmp + 1;
|
||||
}
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
}).detach();
|
||||
|
||||
// Readers try to catch the writer in the act
|
||||
|
|
@ -486,7 +486,7 @@ mod tests {
|
|||
}
|
||||
|
||||
// Wait for writer to finish
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
let lock = arc.read().unwrap();
|
||||
assert_eq!(*lock, 10);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -108,7 +108,7 @@ mod tests {
|
|||
|
||||
use sync::Arc;
|
||||
use super::Semaphore;
|
||||
use comm::channel;
|
||||
use sync::mpsc::channel;
|
||||
use thread::Thread;
|
||||
|
||||
#[test]
|
||||
|
|
@ -143,7 +143,7 @@ mod tests {
|
|||
let s2 = s.clone();
|
||||
let _t = Thread::spawn(move|| {
|
||||
s2.acquire();
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
s.release();
|
||||
let _ = rx.recv();
|
||||
|
|
@ -157,7 +157,7 @@ mod tests {
|
|||
let _ = rx.recv();
|
||||
});
|
||||
s.acquire();
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -171,11 +171,11 @@ mod tests {
|
|||
let _t = Thread::spawn(move|| {
|
||||
let _g = s2.access();
|
||||
let _ = rx2.recv();
|
||||
tx1.send(());
|
||||
tx1.send(()).unwrap();
|
||||
});
|
||||
let _g = s.access();
|
||||
tx2.send(());
|
||||
let _ = rx1.recv();
|
||||
tx2.send(()).unwrap();
|
||||
rx1.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -186,12 +186,12 @@ mod tests {
|
|||
{
|
||||
let _g = s.access();
|
||||
Thread::spawn(move|| {
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
drop(s2.access());
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
}).detach();
|
||||
rx.recv(); // wait for child to come alive
|
||||
rx.recv().unwrap(); // wait for child to come alive
|
||||
}
|
||||
rx.recv(); // wait for child to be done
|
||||
rx.recv().unwrap(); // wait for child to be done
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,9 +12,9 @@
|
|||
|
||||
use core::prelude::*;
|
||||
|
||||
use thread::Thread;
|
||||
use comm::{channel, Sender, Receiver};
|
||||
use sync::{Arc, Mutex};
|
||||
use sync::mpsc::{channel, Sender, Receiver};
|
||||
use thread::Thread;
|
||||
use thunk::Thunk;
|
||||
|
||||
struct Sentinel<'a> {
|
||||
|
|
@ -55,7 +55,7 @@ impl<'a> Drop for Sentinel<'a> {
|
|||
/// ```rust
|
||||
/// use std::sync::TaskPool;
|
||||
/// use std::iter::AdditiveIterator;
|
||||
/// use std::comm::channel;
|
||||
/// use std::sync::mpsc::channel;
|
||||
///
|
||||
/// let pool = TaskPool::new(4u);
|
||||
///
|
||||
|
|
@ -63,7 +63,7 @@ impl<'a> Drop for Sentinel<'a> {
|
|||
/// for _ in range(0, 8u) {
|
||||
/// let tx = tx.clone();
|
||||
/// pool.execute(move|| {
|
||||
/// tx.send(1u);
|
||||
/// tx.send(1u).unwrap();
|
||||
/// });
|
||||
/// }
|
||||
///
|
||||
|
|
@ -101,7 +101,7 @@ impl TaskPool {
|
|||
pub fn execute<F>(&self, job: F)
|
||||
where F : FnOnce(), F : Send
|
||||
{
|
||||
self.jobs.send(Thunk::new(job));
|
||||
self.jobs.send(Thunk::new(job)).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -115,7 +115,7 @@ fn spawn_in_pool(jobs: Arc<Mutex<Receiver<Thunk>>>) {
|
|||
// Only lock jobs for the time it takes
|
||||
// to get a job, not run it.
|
||||
let lock = jobs.lock().unwrap();
|
||||
lock.recv_opt()
|
||||
lock.recv()
|
||||
};
|
||||
|
||||
match message {
|
||||
|
|
@ -134,7 +134,7 @@ fn spawn_in_pool(jobs: Arc<Mutex<Receiver<Thunk>>>) {
|
|||
mod test {
|
||||
use prelude::v1::*;
|
||||
use super::*;
|
||||
use comm::channel;
|
||||
use sync::mpsc::channel;
|
||||
|
||||
const TEST_TASKS: uint = 4u;
|
||||
|
||||
|
|
@ -148,7 +148,7 @@ mod test {
|
|||
for _ in range(0, TEST_TASKS) {
|
||||
let tx = tx.clone();
|
||||
pool.execute(move|| {
|
||||
tx.send(1u);
|
||||
tx.send(1u).unwrap();
|
||||
});
|
||||
}
|
||||
|
||||
|
|
@ -177,7 +177,7 @@ mod test {
|
|||
for _ in range(0, TEST_TASKS) {
|
||||
let tx = tx.clone();
|
||||
pool.execute(move|| {
|
||||
tx.send(1u);
|
||||
tx.send(1u).unwrap();
|
||||
});
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -27,6 +27,7 @@ use comm::{channel, Sender, Receiver};
|
|||
use mem;
|
||||
use rt;
|
||||
use sync::{StaticMutex, StaticCondvar};
|
||||
use sync::mpsc::{channel, Sender, Receiver};
|
||||
use sys::helper_signal;
|
||||
|
||||
use thread::Thread;
|
||||
|
|
@ -118,7 +119,7 @@ impl<M: Send> Helper<M> {
|
|||
// message. Otherwise it could wake up and go to sleep before we
|
||||
// send the message.
|
||||
assert!(!self.chan.get().is_null());
|
||||
(**self.chan.get()).send(msg);
|
||||
(**self.chan.get()).send(msg).unwrap();
|
||||
helper_signal::signal(*self.signal.get() as helper_signal::signal);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,7 +13,6 @@ use self::Req::*;
|
|||
|
||||
use c_str::{CString, ToCStr};
|
||||
use collections;
|
||||
use comm::{channel, Sender, Receiver};
|
||||
use hash::Hash;
|
||||
use io::process::{ProcessExit, ExitStatus, ExitSignal};
|
||||
use io::{mod, IoResult, IoError, EndOfFile};
|
||||
|
|
@ -22,6 +21,7 @@ use mem;
|
|||
use os;
|
||||
use path::BytesContainer;
|
||||
use ptr;
|
||||
use sync::mpsc::{channel, Sender, Receiver};
|
||||
use sys::fs::FileDesc;
|
||||
use sys::{mod, retry, c, wouldblock, set_nonblocking, ms_to_timeval};
|
||||
use sys_common::helper_thread::Helper;
|
||||
|
|
@ -277,8 +277,8 @@ impl Process {
|
|||
}
|
||||
|
||||
pub fn wait(&self, deadline: u64) -> IoResult<ProcessExit> {
|
||||
use std::cmp;
|
||||
use std::comm;
|
||||
use cmp;
|
||||
use sync::mpsc::TryRecvError;
|
||||
|
||||
static mut WRITE_FD: libc::c_int = 0;
|
||||
|
||||
|
|
@ -337,9 +337,9 @@ impl Process {
|
|||
|
||||
let (tx, rx) = channel();
|
||||
unsafe { HELPER.send(NewChild(self.pid, tx, deadline)); }
|
||||
return match rx.recv_opt() {
|
||||
return match rx.recv() {
|
||||
Ok(e) => Ok(e),
|
||||
Err(()) => Err(timeout("wait timed out")),
|
||||
Err(..) => Err(timeout("wait timed out")),
|
||||
};
|
||||
|
||||
// Register a new SIGCHLD handler, returning the reading half of the
|
||||
|
|
@ -420,11 +420,11 @@ impl Process {
|
|||
Ok(NewChild(pid, tx, deadline)) => {
|
||||
active.push((pid, tx, deadline));
|
||||
}
|
||||
Err(comm::Disconnected) => {
|
||||
Err(TryRecvError::Disconnected) => {
|
||||
assert!(active.len() == 0);
|
||||
break 'outer;
|
||||
}
|
||||
Err(comm::Empty) => break,
|
||||
Err(TryRecvError::Empty) => break,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -460,7 +460,7 @@ impl Process {
|
|||
active.retain(|&(pid, ref tx, _)| {
|
||||
let pr = Process { pid: pid };
|
||||
match pr.try_wait() {
|
||||
Some(msg) => { tx.send(msg); false }
|
||||
Some(msg) => { tx.send(msg).unwrap(); false }
|
||||
None => true,
|
||||
}
|
||||
});
|
||||
|
|
|
|||
|
|
@ -49,13 +49,13 @@
|
|||
use prelude::v1::*;
|
||||
use self::Req::*;
|
||||
|
||||
use comm::{mod, channel, Sender, Receiver};
|
||||
use io::IoResult;
|
||||
use libc;
|
||||
use mem;
|
||||
use os;
|
||||
use ptr;
|
||||
use sync::atomic;
|
||||
use sync::mpsc::{channel, Sender, Receiver, TryRecvError};
|
||||
use sys::c;
|
||||
use sys::fs::FileDesc;
|
||||
use sys_common::helper_thread::Helper;
|
||||
|
|
@ -168,7 +168,7 @@ fn helper(input: libc::c_int, messages: Receiver<Req>, _: ()) {
|
|||
1 => {
|
||||
loop {
|
||||
match messages.try_recv() {
|
||||
Err(comm::Disconnected) => {
|
||||
Err(TryRecvError::Disconnected) => {
|
||||
assert!(active.len() == 0);
|
||||
break 'outer;
|
||||
}
|
||||
|
|
@ -179,7 +179,7 @@ fn helper(input: libc::c_int, messages: Receiver<Req>, _: ()) {
|
|||
match dead.iter().position(|&(i, _)| id == i) {
|
||||
Some(i) => {
|
||||
let (_, i) = dead.remove(i);
|
||||
ack.send(i);
|
||||
ack.send(i).unwrap();
|
||||
continue
|
||||
}
|
||||
None => {}
|
||||
|
|
@ -187,7 +187,7 @@ fn helper(input: libc::c_int, messages: Receiver<Req>, _: ()) {
|
|||
let i = active.iter().position(|i| i.id == id);
|
||||
let i = i.expect("no timer found");
|
||||
let t = active.remove(i);
|
||||
ack.send(t);
|
||||
ack.send(t).unwrap();
|
||||
}
|
||||
Err(..) => break
|
||||
}
|
||||
|
|
@ -271,7 +271,7 @@ impl Timer {
|
|||
None => {
|
||||
let (tx, rx) = channel();
|
||||
HELPER.send(RemoveTimer(self.id, tx));
|
||||
rx.recv()
|
||||
rx.recv().unwrap()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -133,7 +133,6 @@ pub mod compat {
|
|||
use intrinsics::{atomic_store_relaxed, transmute};
|
||||
use libc::types::os::arch::extra::{LPCWSTR, HMODULE, LPCSTR, LPVOID};
|
||||
use prelude::v1::*;
|
||||
|
||||
use c_str::ToCStr;
|
||||
|
||||
extern "system" {
|
||||
|
|
|
|||
|
|
@ -444,7 +444,7 @@ mod test {
|
|||
|
||||
use any::{Any, AnyRefExt};
|
||||
use boxed::BoxAny;
|
||||
use comm::{channel, Sender};
|
||||
use sync::mpsc::{channel, Sender};
|
||||
use result;
|
||||
use std::io::{ChanReader, ChanWriter};
|
||||
use super::{Thread, Builder};
|
||||
|
|
@ -471,9 +471,9 @@ mod test {
|
|||
fn test_run_basic() {
|
||||
let (tx, rx) = channel();
|
||||
Thread::spawn(move|| {
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
}).detach();
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -506,7 +506,7 @@ mod test {
|
|||
let tx = tx.clone();
|
||||
Thread::spawn(move|| {
|
||||
if i == 0 {
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
} else {
|
||||
f(i - 1, tx);
|
||||
}
|
||||
|
|
@ -514,7 +514,7 @@ mod test {
|
|||
|
||||
}
|
||||
f(10, tx);
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -523,11 +523,11 @@ mod test {
|
|||
|
||||
Thread::spawn(move|| {
|
||||
Thread::spawn(move|| {
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
}).detach();
|
||||
}).detach();
|
||||
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
fn avoid_copying_the_body<F>(spawnfn: F) where F: FnOnce(Thunk) {
|
||||
|
|
@ -538,10 +538,10 @@ mod test {
|
|||
|
||||
spawnfn(Thunk::new(move|| {
|
||||
let x_in_child = (&*x) as *const int as uint;
|
||||
tx.send(x_in_child);
|
||||
tx.send(x_in_child).unwrap();
|
||||
}));
|
||||
|
||||
let x_in_child = rx.recv();
|
||||
let x_in_child = rx.recv().unwrap();
|
||||
assert_eq!(x_in_parent, x_in_child);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -455,7 +455,7 @@ mod imp {
|
|||
mod tests {
|
||||
use prelude::v1::*;
|
||||
|
||||
use comm::{channel, Sender};
|
||||
use sync::mpsc::{channel, Sender};
|
||||
use cell::UnsafeCell;
|
||||
use thread::Thread;
|
||||
|
||||
|
|
@ -464,7 +464,7 @@ mod tests {
|
|||
impl Drop for Foo {
|
||||
fn drop(&mut self) {
|
||||
let Foo(ref s) = *self;
|
||||
s.send(());
|
||||
s.send(()).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -481,9 +481,9 @@ mod tests {
|
|||
FOO.with(|f| unsafe {
|
||||
assert_eq!(*f.get(), 1);
|
||||
});
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
|
||||
FOO.with(|f| unsafe {
|
||||
assert_eq!(*f.get(), 2);
|
||||
|
|
@ -503,7 +503,7 @@ mod tests {
|
|||
*f.get() = Some(Foo(tx.take().unwrap()));
|
||||
});
|
||||
});
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -594,7 +594,7 @@ mod tests {
|
|||
let mut tx = Some(tx);
|
||||
K1.with(|s| *s.get() = Some(S1(tx.take().unwrap())));
|
||||
});
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -59,7 +59,6 @@ use term::color::{Color, RED, YELLOW, GREEN, CYAN};
|
|||
use std::any::{Any, AnyRefExt};
|
||||
use std::cmp;
|
||||
use std::collections::BTreeMap;
|
||||
use std::comm::{channel, Sender};
|
||||
use std::f64;
|
||||
use std::fmt::Show;
|
||||
use std::fmt;
|
||||
|
|
@ -71,6 +70,7 @@ use std::iter::repeat;
|
|||
use std::num::{Float, FloatMath, Int};
|
||||
use std::os;
|
||||
use std::str::{FromStr, from_str};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
use std::thread::{mod, Thread};
|
||||
use std::thunk::{Thunk, Invoke};
|
||||
use std::time::Duration;
|
||||
|
|
@ -1021,7 +1021,7 @@ fn run_tests<F>(opts: &TestOpts,
|
|||
pending += 1;
|
||||
}
|
||||
|
||||
let (desc, result, stdout) = rx.recv();
|
||||
let (desc, result, stdout) = rx.recv().unwrap();
|
||||
if concurrency != 1 {
|
||||
try!(callback(TeWait(desc.clone(), PadNone)));
|
||||
}
|
||||
|
|
@ -1034,7 +1034,7 @@ fn run_tests<F>(opts: &TestOpts,
|
|||
for b in filtered_benchs_and_metrics.into_iter() {
|
||||
try!(callback(TeWait(b.desc.clone(), b.testfn.padding())));
|
||||
run_test(opts, !opts.run_benchmarks, b, tx.clone());
|
||||
let (test, result, stdout) = rx.recv();
|
||||
let (test, result, stdout) = rx.recv().unwrap();
|
||||
try!(callback(TeResult(test, result, stdout)));
|
||||
}
|
||||
Ok(())
|
||||
|
|
@ -1111,7 +1111,7 @@ pub fn run_test(opts: &TestOpts,
|
|||
let TestDescAndFn {desc, testfn} = test;
|
||||
|
||||
if force_ignore || desc.ignore {
|
||||
monitor_ch.send((desc, TrIgnored, Vec::new()));
|
||||
monitor_ch.send((desc, TrIgnored, Vec::new())).unwrap();
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -1138,31 +1138,31 @@ pub fn run_test(opts: &TestOpts,
|
|||
let result_guard = cfg.spawn(move || { testfn.invoke(()) });
|
||||
let stdout = reader.read_to_end().unwrap().into_iter().collect();
|
||||
let test_result = calc_result(&desc, result_guard.join());
|
||||
monitor_ch.send((desc.clone(), test_result, stdout));
|
||||
monitor_ch.send((desc.clone(), test_result, stdout)).unwrap();
|
||||
}).detach();
|
||||
}
|
||||
|
||||
match testfn {
|
||||
DynBenchFn(bencher) => {
|
||||
let bs = ::bench::benchmark(|harness| bencher.run(harness));
|
||||
monitor_ch.send((desc, TrBench(bs), Vec::new()));
|
||||
monitor_ch.send((desc, TrBench(bs), Vec::new())).unwrap();
|
||||
return;
|
||||
}
|
||||
StaticBenchFn(benchfn) => {
|
||||
let bs = ::bench::benchmark(|harness| (benchfn.clone())(harness));
|
||||
monitor_ch.send((desc, TrBench(bs), Vec::new()));
|
||||
monitor_ch.send((desc, TrBench(bs), Vec::new())).unwrap();
|
||||
return;
|
||||
}
|
||||
DynMetricFn(f) => {
|
||||
let mut mm = MetricMap::new();
|
||||
f.invoke(&mut mm);
|
||||
monitor_ch.send((desc, TrMetrics(mm), Vec::new()));
|
||||
monitor_ch.send((desc, TrMetrics(mm), Vec::new())).unwrap();
|
||||
return;
|
||||
}
|
||||
StaticMetricFn(f) => {
|
||||
let mut mm = MetricMap::new();
|
||||
f(&mut mm);
|
||||
monitor_ch.send((desc, TrMetrics(mm), Vec::new()));
|
||||
monitor_ch.send((desc, TrMetrics(mm), Vec::new())).unwrap();
|
||||
return;
|
||||
}
|
||||
DynTestFn(f) => run_test_inner(desc, monitor_ch, opts.nocapture, f),
|
||||
|
|
@ -1466,7 +1466,7 @@ mod tests {
|
|||
StaticTestName, DynTestName, DynTestFn, ShouldFail};
|
||||
use std::io::TempDir;
|
||||
use std::thunk::Thunk;
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
|
||||
#[test]
|
||||
pub fn do_not_run_ignored_tests() {
|
||||
|
|
@ -1481,7 +1481,7 @@ mod tests {
|
|||
};
|
||||
let (tx, rx) = channel();
|
||||
run_test(&TestOpts::new(), false, desc, tx);
|
||||
let (_, res, _) = rx.recv();
|
||||
let (_, res, _) = rx.recv().unwrap();
|
||||
assert!(res != TrOk);
|
||||
}
|
||||
|
||||
|
|
@ -1498,7 +1498,7 @@ mod tests {
|
|||
};
|
||||
let (tx, rx) = channel();
|
||||
run_test(&TestOpts::new(), false, desc, tx);
|
||||
let (_, res, _) = rx.recv();
|
||||
let (_, res, _) = rx.recv().unwrap();
|
||||
assert!(res == TrIgnored);
|
||||
}
|
||||
|
||||
|
|
@ -1515,7 +1515,7 @@ mod tests {
|
|||
};
|
||||
let (tx, rx) = channel();
|
||||
run_test(&TestOpts::new(), false, desc, tx);
|
||||
let (_, res, _) = rx.recv();
|
||||
let (_, res, _) = rx.recv().unwrap();
|
||||
assert!(res == TrOk);
|
||||
}
|
||||
|
||||
|
|
@ -1532,7 +1532,7 @@ mod tests {
|
|||
};
|
||||
let (tx, rx) = channel();
|
||||
run_test(&TestOpts::new(), false, desc, tx);
|
||||
let (_, res, _) = rx.recv();
|
||||
let (_, res, _) = rx.recv().unwrap();
|
||||
assert!(res == TrOk);
|
||||
}
|
||||
|
||||
|
|
@ -1549,7 +1549,7 @@ mod tests {
|
|||
};
|
||||
let (tx, rx) = channel();
|
||||
run_test(&TestOpts::new(), false, desc, tx);
|
||||
let (_, res, _) = rx.recv();
|
||||
let (_, res, _) = rx.recv().unwrap();
|
||||
assert!(res == TrFailed);
|
||||
}
|
||||
|
||||
|
|
@ -1566,7 +1566,7 @@ mod tests {
|
|||
};
|
||||
let (tx, rx) = channel();
|
||||
run_test(&TestOpts::new(), false, desc, tx);
|
||||
let (_, res, _) = rx.recv();
|
||||
let (_, res, _) = rx.recv().unwrap();
|
||||
assert!(res == TrFailed);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
// except according to those terms.
|
||||
|
||||
use std::task;
|
||||
use std::comm::{Receiver, channel};
|
||||
use std::sync::mpsc::{Receiver, channel};
|
||||
|
||||
pub fn foo<T:Send + Clone>(x: T) -> Receiver<T> {
|
||||
let (tx, rx) = channel();
|
||||
|
|
|
|||
|
|
@ -8,15 +8,16 @@
|
|||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
|
||||
fn main() {
|
||||
let (tx, rx) = channel();
|
||||
let x = Some(rx);
|
||||
tx.send(false);
|
||||
match x {
|
||||
Some(z) if z.recv() => { panic!() }, //~ ERROR cannot bind by-move into a pattern guard
|
||||
Some(z) => { assert!(!z.recv()); },
|
||||
Some(z) if z.recv().unwrap() => { panic!() },
|
||||
//~^ ERROR cannot bind by-move into a pattern guard
|
||||
Some(z) => { assert!(!z.recv().unwrap()); },
|
||||
None => panic!()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
// Tests (negatively) the ability for the Self type in default methods
|
||||
// to use capabilities granted by builtin kinds as supertraits.
|
||||
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
|
||||
trait Foo : Sync+'static {
|
||||
fn foo(self, mut chan: Sender<Self>) { }
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::comm::Receiver;
|
||||
use std::sync::mpsc::Receiver;
|
||||
|
||||
fn test<T: Sync>() {}
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::comm::Sender;
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
fn test<T: Sync>() {}
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
use std::thread::Thread;
|
||||
|
||||
fn main() {
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
|
||||
// Test that a class with an unsendable field can't be
|
||||
// sent
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
// a Send. Basically this just makes sure rustc is using
|
||||
// each_bound_trait_and_supertraits in type_contents correctly.
|
||||
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
|
||||
trait Bar : Send { }
|
||||
trait Foo : Bar { }
|
||||
|
|
@ -23,11 +23,11 @@ impl <T: Send> Foo for T { }
|
|||
impl <T: Send> Bar for T { }
|
||||
|
||||
fn foo<T: Foo>(val: T, chan: Sender<T>) {
|
||||
chan.send(val);
|
||||
chan.send(val).unwrap();
|
||||
}
|
||||
|
||||
pub fn main() {
|
||||
let (tx, rx) = channel();
|
||||
foo(31337i, tx);
|
||||
assert!(rx.recv() == 31337i);
|
||||
assert!(rx.recv().unwrap() == 31337i);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@
|
|||
|
||||
extern crate trait_superkinds_in_metadata;
|
||||
|
||||
use std::comm::{channel, Sender, Receiver};
|
||||
use std::sync::mpsc::{channel, Sender, Receiver};
|
||||
use trait_superkinds_in_metadata::{RequiresRequiresShareAndSend, RequiresShare};
|
||||
|
||||
#[deriving(PartialEq)]
|
||||
|
|
@ -26,11 +26,11 @@ impl <T: Sync> RequiresShare for X<T> { }
|
|||
impl <T: Sync+Send> RequiresRequiresShareAndSend for X<T> { }
|
||||
|
||||
fn foo<T: RequiresRequiresShareAndSend>(val: T, chan: Sender<T>) {
|
||||
chan.send(val);
|
||||
chan.send(val).unwrap();
|
||||
}
|
||||
|
||||
pub fn main() {
|
||||
let (tx, rx): (Sender<X<int>>, Receiver<X<int>>) = channel();
|
||||
foo(X(31337i), tx);
|
||||
assert!(rx.recv() == X(31337i));
|
||||
assert!(rx.recv().unwrap() == X(31337i));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,18 +12,18 @@
|
|||
// builtin-kinds, e.g., if a trait requires Send to implement, then
|
||||
// at usage site of that trait, we know we have the Send capability.
|
||||
|
||||
use std::comm::{channel, Sender, Receiver};
|
||||
use std::sync::mpsc::{channel, Sender, Receiver};
|
||||
|
||||
trait Foo : Send { }
|
||||
|
||||
impl <T: Send> Foo for T { }
|
||||
|
||||
fn foo<T: Foo>(val: T, chan: Sender<T>) {
|
||||
chan.send(val);
|
||||
chan.send(val).unwrap();
|
||||
}
|
||||
|
||||
pub fn main() {
|
||||
let (tx, rx): (Sender<int>, Receiver<int>) = channel();
|
||||
foo(31337i, tx);
|
||||
assert!(rx.recv() == 31337i);
|
||||
assert!(rx.recv().unwrap() == 31337i);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,11 +11,11 @@
|
|||
// Tests the ability for the Self type in default methods to use
|
||||
// capabilities granted by builtin kinds as supertraits.
|
||||
|
||||
use std::comm::{Sender, channel};
|
||||
use std::sync::mpsc::{Sender, channel};
|
||||
|
||||
trait Foo : Send {
|
||||
fn foo(self, tx: Sender<Self>) {
|
||||
tx.send(self);
|
||||
tx.send(self).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -24,5 +24,5 @@ impl <T: Send> Foo for T { }
|
|||
pub fn main() {
|
||||
let (tx, rx) = channel();
|
||||
1193182i.foo(tx);
|
||||
assert!(rx.recv() == 1193182i);
|
||||
assert!(rx.recv().unwrap() == 1193182i);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
extern crate log;
|
||||
|
||||
use log::{set_logger, Logger, LogRecord};
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
use std::fmt;
|
||||
use std::io::{ChanReader, ChanWriter};
|
||||
use std::thread::Thread;
|
||||
|
|
|
|||
|
|
@ -16,5 +16,5 @@
|
|||
extern crate cci_capture_clause;
|
||||
|
||||
pub fn main() {
|
||||
cci_capture_clause::foo(()).recv()
|
||||
cci_capture_clause::foo(()).recv().unwrap();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
#![feature(unboxed_closures)]
|
||||
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
|
||||
fn foo<F:FnOnce()+Send>(blk: F) {
|
||||
blk();
|
||||
|
|
@ -19,7 +19,7 @@ fn foo<F:FnOnce()+Send>(blk: F) {
|
|||
pub fn main() {
|
||||
let (tx, rx) = channel();
|
||||
foo(move || {
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
rx.recv();
|
||||
rx.recv().unwrap();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,12 +9,12 @@
|
|||
// except according to those terms.
|
||||
|
||||
use std::task;
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
|
||||
pub fn main() {
|
||||
let (tx, rx) = channel();
|
||||
let _t = task::spawn(move|| { child(&tx) });
|
||||
let y = rx.recv();
|
||||
let y = rx.recv().unwrap();
|
||||
println!("received");
|
||||
println!("{}", y);
|
||||
assert_eq!(y, 10);
|
||||
|
|
@ -22,6 +22,6 @@ pub fn main() {
|
|||
|
||||
fn child(c: &Sender<int>) {
|
||||
println!("sending");
|
||||
c.send(10);
|
||||
c.send(10).unwrap();
|
||||
println!("value sent");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ extern crate libc;
|
|||
use std::io::{Process, Command, timer};
|
||||
use std::time::Duration;
|
||||
use std::str;
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
use std::thread::Thread;
|
||||
|
||||
macro_rules! succeed( ($e:expr) => (
|
||||
|
|
@ -88,13 +88,13 @@ pub fn test_destroy_actually_kills(force: bool) {
|
|||
let rx2 = t.oneshot(Duration::milliseconds(1000));
|
||||
Thread::spawn(move|| {
|
||||
select! {
|
||||
() = rx2.recv() => unsafe { libc::exit(1) },
|
||||
() = rx1.recv() => {}
|
||||
_ = rx2.recv() => unsafe { libc::exit(1) },
|
||||
_ = rx1.recv() => {}
|
||||
}
|
||||
}).detach();
|
||||
match p.wait().unwrap() {
|
||||
ExitStatus(..) => panic!("expected a signal"),
|
||||
ExitSignal(..) => tx.send(()),
|
||||
ExitSignal(..) => tx.send(()).unwrap(),
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
// except according to those terms.
|
||||
|
||||
use std::task;
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
|
||||
#[deriving(PartialEq, Show)]
|
||||
enum Message {
|
||||
|
|
@ -23,7 +23,7 @@ struct SendOnDrop {
|
|||
|
||||
impl Drop for SendOnDrop {
|
||||
fn drop(&mut self) {
|
||||
self.sender.send(Message::Dropped);
|
||||
self.sender.send(Message::Dropped).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -37,10 +37,10 @@ impl Drop for Foo {
|
|||
fn drop(&mut self) {
|
||||
match self {
|
||||
&Foo::SimpleVariant(ref mut sender) => {
|
||||
sender.send(Message::DestructorRan);
|
||||
sender.send(Message::DestructorRan).unwrap();
|
||||
}
|
||||
&Foo::NestedVariant(_, _, ref mut sender) => {
|
||||
sender.send(Message::DestructorRan);
|
||||
sender.send(Message::DestructorRan).unwrap();
|
||||
}
|
||||
&Foo::FailingVariant { .. } => {
|
||||
panic!("Failed");
|
||||
|
|
@ -54,23 +54,23 @@ pub fn main() {
|
|||
{
|
||||
let v = Foo::SimpleVariant(sender);
|
||||
}
|
||||
assert_eq!(receiver.recv(), Message::DestructorRan);
|
||||
assert_eq!(receiver.recv_opt().ok(), None);
|
||||
assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
|
||||
assert_eq!(receiver.recv().ok(), None);
|
||||
|
||||
let (sender, receiver) = channel();
|
||||
{
|
||||
let v = Foo::NestedVariant(box 42u, SendOnDrop { sender: sender.clone() }, sender);
|
||||
}
|
||||
assert_eq!(receiver.recv(), Message::DestructorRan);
|
||||
assert_eq!(receiver.recv(), Message::Dropped);
|
||||
assert_eq!(receiver.recv_opt().ok(), None);
|
||||
assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
|
||||
assert_eq!(receiver.recv().unwrap(), Message::Dropped);
|
||||
assert_eq!(receiver.recv().ok(), None);
|
||||
|
||||
let (sender, receiver) = channel();
|
||||
task::spawn(move|| {
|
||||
let v = Foo::FailingVariant { on_drop: SendOnDrop { sender: sender } };
|
||||
});
|
||||
assert_eq!(receiver.recv(), Message::Dropped);
|
||||
assert_eq!(receiver.recv_opt().ok(), None);
|
||||
assert_eq!(receiver.recv().unwrap(), Message::Dropped);
|
||||
assert_eq!(receiver.recv().ok(), None);
|
||||
|
||||
let (sender, receiver) = channel();
|
||||
{
|
||||
|
|
@ -83,11 +83,11 @@ pub fn main() {
|
|||
v = Foo::FailingVariant { on_drop: SendOnDrop { sender: sender } };
|
||||
});
|
||||
}
|
||||
assert_eq!(receiver.recv(), Message::DestructorRan);
|
||||
assert_eq!(receiver.recv(), Message::Dropped);
|
||||
assert_eq!(receiver.recv(), Message::DestructorRan);
|
||||
assert_eq!(receiver.recv(), Message::Dropped);
|
||||
assert_eq!(receiver.recv(), Message::DestructorRan);
|
||||
assert_eq!(receiver.recv(), Message::Dropped);
|
||||
assert_eq!(receiver.recv_opt().ok(), None);
|
||||
assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
|
||||
assert_eq!(receiver.recv().unwrap(), Message::Dropped);
|
||||
assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
|
||||
assert_eq!(receiver.recv().unwrap(), Message::Dropped);
|
||||
assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
|
||||
assert_eq!(receiver.recv().unwrap(), Message::Dropped);
|
||||
assert_eq!(receiver.recv().ok(), None);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ pub fn map(filename: String, emit: map_reduce::putter) {
|
|||
|
||||
mod map_reduce {
|
||||
use std::collections::HashMap;
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
use std::str;
|
||||
use std::task;
|
||||
|
||||
|
|
@ -50,16 +50,16 @@ mod map_reduce {
|
|||
}
|
||||
let (tx, rx) = channel();
|
||||
println!("sending find_reducer");
|
||||
ctrl.send(ctrl_proto::find_reducer(key.as_bytes().to_vec(), tx));
|
||||
ctrl.send(ctrl_proto::find_reducer(key.as_bytes().to_vec(), tx)).unwrap();
|
||||
println!("receiving");
|
||||
let c = rx.recv();
|
||||
let c = rx.recv().unwrap();
|
||||
println!("{}", c);
|
||||
im.insert(key, c);
|
||||
}
|
||||
|
||||
let ctrl_clone = ctrl.clone();
|
||||
::map(input, |a,b| emit(&mut intermediates, ctrl.clone(), a, b) );
|
||||
ctrl_clone.send(ctrl_proto::mapper_done);
|
||||
ctrl_clone.send(ctrl_proto::mapper_done).unwrap();
|
||||
}
|
||||
|
||||
pub fn map_reduce(inputs: Vec<String>) {
|
||||
|
|
@ -77,7 +77,7 @@ mod map_reduce {
|
|||
let mut num_mappers = inputs.len() as int;
|
||||
|
||||
while num_mappers > 0 {
|
||||
match rx.recv() {
|
||||
match rx.recv().unwrap() {
|
||||
ctrl_proto::mapper_done => { num_mappers -= 1; }
|
||||
ctrl_proto::find_reducer(k, cc) => {
|
||||
let mut c;
|
||||
|
|
@ -86,7 +86,7 @@ mod map_reduce {
|
|||
Some(&_c) => { c = _c; }
|
||||
None => { c = 0; }
|
||||
}
|
||||
cc.send(c);
|
||||
cc.send(c).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,12 +11,12 @@
|
|||
// This test may not always fail, but it can be flaky if the race it used to
|
||||
// expose is still present.
|
||||
|
||||
use std::comm::{channel, Sender, Receiver};
|
||||
use std::sync::mpsc::{channel, Sender, Receiver};
|
||||
use std::thread::Thread;
|
||||
|
||||
fn helper(rx: Receiver<Sender<()>>) {
|
||||
for tx in rx.iter() {
|
||||
let _ = tx.send_opt(());
|
||||
let _ = tx.send(());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -25,11 +25,11 @@ fn main() {
|
|||
let _t = Thread::spawn(move|| { helper(rx) }).detach();
|
||||
let (snd, rcv) = channel::<int>();
|
||||
for _ in range(1i, 100000i) {
|
||||
snd.send(1i);
|
||||
snd.send(1i).unwrap();
|
||||
let (tx2, rx2) = channel();
|
||||
tx.send(tx2);
|
||||
tx.send(tx2).unwrap();
|
||||
select! {
|
||||
() = rx2.recv() => (),
|
||||
_ = rx2.recv() => (),
|
||||
_ = rcv.recv() => ()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
#![feature(default_type_params)]
|
||||
|
||||
use std::task;
|
||||
use std::comm::Sender;
|
||||
use std::sync::mpsc::Sender;
|
||||
use std::thunk::Invoke;
|
||||
|
||||
type RingBuffer = Vec<f64> ;
|
||||
|
|
|
|||
|
|
@ -9,15 +9,15 @@
|
|||
// except according to those terms.
|
||||
|
||||
use std::io::println;
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
use std::thread::Thread;
|
||||
|
||||
pub fn main() {
|
||||
let (tx, rx) = channel();
|
||||
|
||||
tx.send("hello, world");
|
||||
tx.send("hello, world").unwrap();
|
||||
|
||||
Thread::spawn(move|| {
|
||||
println(rx.recv());
|
||||
println(rx.recv().unwrap());
|
||||
}).join().ok().unwrap();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,15 +8,16 @@
|
|||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::task;
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
use std::thread::Thread;
|
||||
|
||||
pub fn main() {
|
||||
let (tx, rx) = channel::<&'static str>();
|
||||
|
||||
task::spawn(move|| {
|
||||
assert_eq!(rx.recv(), "hello, world");
|
||||
let t = Thread::spawn(move|| {
|
||||
assert_eq!(rx.recv().unwrap(), "hello, world");
|
||||
});
|
||||
|
||||
tx.send("hello, world");
|
||||
tx.send("hello, world").unwrap();
|
||||
t.join().ok().unwrap();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,19 +9,19 @@
|
|||
// except according to those terms.
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::comm::{channel, Receiver};
|
||||
use std::sync::mpsc::{channel, Receiver};
|
||||
|
||||
fn periodical(n: int) -> Receiver<bool> {
|
||||
let (chan, port) = channel();
|
||||
Thread::spawn(move|| {
|
||||
loop {
|
||||
for _ in range(1, n) {
|
||||
match chan.send_opt(false) {
|
||||
match chan.send(false) {
|
||||
Ok(()) => {}
|
||||
Err(..) => break,
|
||||
}
|
||||
}
|
||||
match chan.send_opt(true) {
|
||||
match chan.send(true) {
|
||||
Ok(()) => {}
|
||||
Err(..) => break
|
||||
}
|
||||
|
|
@ -35,7 +35,7 @@ fn integers() -> Receiver<int> {
|
|||
Thread::spawn(move|| {
|
||||
let mut i = 1;
|
||||
loop {
|
||||
match chan.send_opt(i) {
|
||||
match chan.send(i) {
|
||||
Ok(()) => {}
|
||||
Err(..) => break,
|
||||
}
|
||||
|
|
@ -50,7 +50,7 @@ fn main() {
|
|||
let threes = periodical(3);
|
||||
let fives = periodical(5);
|
||||
for _ in range(1i, 100i) {
|
||||
match (ints.recv(), threes.recv(), fives.recv()) {
|
||||
match (ints.recv().unwrap(), threes.recv().unwrap(), fives.recv().unwrap()) {
|
||||
(_, true, true) => println!("FizzBuzz"),
|
||||
(_, true, false) => println!("Fizz"),
|
||||
(_, false, true) => println!("Buzz"),
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::comm::{mod, channel};
|
||||
use std::sync::mpsc::{TryRecvError, channel};
|
||||
use std::io::timer::Timer;
|
||||
use std::thread::Thread;
|
||||
use std::time::Duration;
|
||||
|
|
@ -18,13 +18,13 @@ pub fn main() {
|
|||
let _t = Thread::spawn(move||{
|
||||
let mut timer = Timer::new().unwrap();
|
||||
timer.sleep(Duration::milliseconds(10));
|
||||
tx.send(());
|
||||
tx.send(()).unwrap();
|
||||
});
|
||||
loop {
|
||||
match rx.try_recv() {
|
||||
Ok(()) => break,
|
||||
Err(comm::Empty) => {}
|
||||
Err(comm::Disconnected) => unreachable!()
|
||||
Err(TryRecvError::Empty) => {}
|
||||
Err(TryRecvError::Disconnected) => unreachable!()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,12 +9,12 @@
|
|||
// except according to those terms.
|
||||
|
||||
use std::task;
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
|
||||
fn producer(tx: &Sender<Vec<u8>>) {
|
||||
tx.send(
|
||||
vec!(1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8, 10u8, 11u8, 12u8,
|
||||
13u8));
|
||||
13u8)).unwrap();
|
||||
}
|
||||
|
||||
pub fn main() {
|
||||
|
|
@ -23,5 +23,5 @@ pub fn main() {
|
|||
producer(&tx)
|
||||
});
|
||||
|
||||
let _data: Vec<u8> = rx.recv();
|
||||
let _data: Vec<u8> = rx.recv().unwrap();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
#[phase(plugin,link)]
|
||||
extern crate log;
|
||||
|
||||
use std::comm::{channel, Sender, Receiver};
|
||||
use std::sync::mpsc::{channel, Sender, Receiver};
|
||||
use std::thread::Thread;
|
||||
|
||||
pub struct ChannelLogger {
|
||||
|
|
@ -30,7 +30,7 @@ impl ChannelLogger {
|
|||
|
||||
impl log::Logger for ChannelLogger {
|
||||
fn log(&mut self, record: &log::LogRecord) {
|
||||
self.tx.send(format!("{}", record.args));
|
||||
self.tx.send(format!("{}", record.args)).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -49,9 +49,9 @@ pub fn main() {
|
|||
info!("f1o");
|
||||
});
|
||||
|
||||
assert_eq!(rx.recv().as_slice(), "foo");
|
||||
assert_eq!(rx.recv().as_slice(), "foo bar");
|
||||
assert_eq!(rx.recv().as_slice(), "bar foo");
|
||||
assert_eq!(rx.recv().as_slice(), "f1o");
|
||||
assert!(rx.recv_opt().is_err());
|
||||
assert_eq!(rx.recv().unwrap().as_slice(), "foo");
|
||||
assert_eq!(rx.recv().unwrap().as_slice(), "foo bar");
|
||||
assert_eq!(rx.recv().unwrap().as_slice(), "bar foo");
|
||||
assert_eq!(rx.recv().unwrap().as_slice(), "f1o");
|
||||
assert!(rx.recv().is_err());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
// except according to those terms.
|
||||
|
||||
use std::task;
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
|
||||
struct test {
|
||||
f: int,
|
||||
|
|
@ -30,10 +30,10 @@ pub fn main() {
|
|||
|
||||
task::spawn(move|| {
|
||||
let (tx2, rx2) = channel();
|
||||
tx.send(tx2);
|
||||
tx.send(tx2).unwrap();
|
||||
|
||||
let _r = rx2.recv();
|
||||
let _r = rx2.recv().unwrap();
|
||||
});
|
||||
|
||||
rx.recv().send(test(42));
|
||||
rx.recv().unwrap().send(test(42)).unwrap();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
|
||||
// tests that ctrl's type gets inferred properly
|
||||
struct Command<K, V> {
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
// Test that a class with only sendable fields can be sent
|
||||
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
|
||||
struct foo {
|
||||
i: int,
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
*/
|
||||
|
||||
use std::task;
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
|
||||
type ctx = Sender<int>;
|
||||
|
||||
|
|
|
|||
|
|
@ -9,27 +9,27 @@
|
|||
// except according to those terms.
|
||||
|
||||
use std::task;
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
|
||||
pub fn main() { test05(); }
|
||||
|
||||
fn test05_start(tx : &Sender<int>) {
|
||||
tx.send(10);
|
||||
tx.send(10).unwrap();
|
||||
println!("sent 10");
|
||||
tx.send(20);
|
||||
tx.send(20).unwrap();
|
||||
println!("sent 20");
|
||||
tx.send(30);
|
||||
tx.send(30).unwrap();
|
||||
println!("sent 30");
|
||||
}
|
||||
|
||||
fn test05() {
|
||||
let (tx, rx) = channel();
|
||||
task::spawn(move|| { test05_start(&tx) });
|
||||
let mut value: int = rx.recv();
|
||||
let mut value: int = rx.recv().unwrap();
|
||||
println!("{}", value);
|
||||
value = rx.recv();
|
||||
value = rx.recv().unwrap();
|
||||
println!("{}", value);
|
||||
value = rx.recv();
|
||||
value = rx.recv().unwrap();
|
||||
println!("{}", value);
|
||||
assert_eq!(value, 30);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,18 +9,18 @@
|
|||
// except according to those terms.
|
||||
|
||||
use std::task;
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
|
||||
fn start(tx: &Sender<Sender<String>>) {
|
||||
let (tx2, rx) = channel();
|
||||
tx.send(tx2);
|
||||
tx.send(tx2).unwrap();
|
||||
|
||||
let mut a;
|
||||
let mut b;
|
||||
a = rx.recv();
|
||||
a = rx.recv().unwrap();
|
||||
assert!(a == "A".to_string());
|
||||
println!("{}", a);
|
||||
b = rx.recv();
|
||||
b = rx.recv().unwrap();
|
||||
assert!(b == "B".to_string());
|
||||
println!("{}", b);
|
||||
}
|
||||
|
|
@ -29,8 +29,8 @@ pub fn main() {
|
|||
let (tx, rx) = channel();
|
||||
let _child = task::spawn(move|| { start(&tx) });
|
||||
|
||||
let mut c = rx.recv();
|
||||
c.send("A".to_string());
|
||||
c.send("B".to_string());
|
||||
let mut c = rx.recv().unwrap();
|
||||
c.send("A".to_string()).unwrap();
|
||||
c.send("B".to_string()).unwrap();
|
||||
task::deschedule();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
use std::task;
|
||||
|
||||
fn start(tx: &Sender<Sender<int>>) {
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
use std::task;
|
||||
|
||||
fn start(tx: &Sender<int>, start: int, number_of_messages: int) {
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
use std::task;
|
||||
|
||||
pub fn main() {
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
use std::task;
|
||||
|
||||
fn start(tx: &Sender<int>, i0: int) {
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
use std::cmp;
|
||||
|
||||
// Tests of ports and channels on various types
|
||||
|
|
@ -17,9 +17,9 @@ fn test_rec() {
|
|||
|
||||
let (tx, rx) = channel();
|
||||
let r0: R = R {val0: 0, val1: 1u8, val2: '2'};
|
||||
tx.send(r0);
|
||||
tx.send(r0).unwrap();
|
||||
let mut r1: R;
|
||||
r1 = rx.recv();
|
||||
r1 = rx.recv().unwrap();
|
||||
assert_eq!(r1.val0, 0);
|
||||
assert_eq!(r1.val1, 1u8);
|
||||
assert_eq!(r1.val2, '2');
|
||||
|
|
@ -28,8 +28,8 @@ fn test_rec() {
|
|||
fn test_vec() {
|
||||
let (tx, rx) = channel();
|
||||
let v0: Vec<int> = vec!(0, 1, 2);
|
||||
tx.send(v0);
|
||||
let v1 = rx.recv();
|
||||
tx.send(v0).unwrap();
|
||||
let v1 = rx.recv().unwrap();
|
||||
assert_eq!(v1[0], 0);
|
||||
assert_eq!(v1[1], 1);
|
||||
assert_eq!(v1[2], 2);
|
||||
|
|
@ -38,8 +38,8 @@ fn test_vec() {
|
|||
fn test_str() {
|
||||
let (tx, rx) = channel();
|
||||
let s0 = "test".to_string();
|
||||
tx.send(s0);
|
||||
let s1 = rx.recv();
|
||||
tx.send(s0).unwrap();
|
||||
let s1 = rx.recv().unwrap();
|
||||
assert_eq!(s1.as_bytes()[0], 't' as u8);
|
||||
assert_eq!(s1.as_bytes()[1], 'e' as u8);
|
||||
assert_eq!(s1.as_bytes()[2], 's' as u8);
|
||||
|
|
@ -82,28 +82,28 @@ impl cmp::PartialEq for t {
|
|||
|
||||
fn test_tag() {
|
||||
let (tx, rx) = channel();
|
||||
tx.send(t::tag1);
|
||||
tx.send(t::tag2(10));
|
||||
tx.send(t::tag3(10, 11u8, 'A'));
|
||||
tx.send(t::tag1).unwrap();
|
||||
tx.send(t::tag2(10)).unwrap();
|
||||
tx.send(t::tag3(10, 11u8, 'A')).unwrap();
|
||||
let mut t1: t;
|
||||
t1 = rx.recv();
|
||||
t1 = rx.recv().unwrap();
|
||||
assert_eq!(t1, t::tag1);
|
||||
t1 = rx.recv();
|
||||
t1 = rx.recv().unwrap();
|
||||
assert_eq!(t1, t::tag2(10));
|
||||
t1 = rx.recv();
|
||||
t1 = rx.recv().unwrap();
|
||||
assert_eq!(t1, t::tag3(10, 11u8, 'A'));
|
||||
}
|
||||
|
||||
fn test_chan() {
|
||||
let (tx1, rx1) = channel();
|
||||
let (tx2, rx2) = channel();
|
||||
tx1.send(tx2);
|
||||
let tx2 = rx1.recv();
|
||||
tx1.send(tx2).unwrap();
|
||||
let tx2 = rx1.recv().unwrap();
|
||||
// Does the transmitted channel still work?
|
||||
|
||||
tx2.send(10);
|
||||
tx2.send(10).unwrap();
|
||||
let mut i: int;
|
||||
i = rx2.recv();
|
||||
i = rx2.recv().unwrap();
|
||||
assert_eq!(i, 10);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
// no-pretty-expanded FIXME #15189
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
|
||||
pub fn main() { println!("===== WITHOUT THREADS ====="); test00(); }
|
||||
|
||||
|
|
@ -20,7 +20,7 @@ fn test00_start(ch: &Sender<int>, message: int, count: int) {
|
|||
let mut i: int = 0;
|
||||
while i < count {
|
||||
println!("Sending Message");
|
||||
ch.send(message + 0);
|
||||
ch.send(message + 0).unwrap();
|
||||
i = i + 1;
|
||||
}
|
||||
println!("Ending test00_start");
|
||||
|
|
@ -54,7 +54,7 @@ fn test00() {
|
|||
for _r in results.iter() {
|
||||
i = 0;
|
||||
while i < number_of_messages {
|
||||
let value = rx.recv();
|
||||
let value = rx.recv().unwrap();
|
||||
sum += value;
|
||||
i = i + 1;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
#![allow(dead_assignment)]
|
||||
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
|
||||
pub fn main() { test00(); }
|
||||
|
||||
|
|
@ -18,36 +18,36 @@ fn test00() {
|
|||
let mut r: int = 0;
|
||||
let mut sum: int = 0;
|
||||
let (tx, rx) = channel();
|
||||
tx.send(1);
|
||||
tx.send(2);
|
||||
tx.send(3);
|
||||
tx.send(4);
|
||||
r = rx.recv();
|
||||
tx.send(1).unwrap();
|
||||
tx.send(2).unwrap();
|
||||
tx.send(3).unwrap();
|
||||
tx.send(4).unwrap();
|
||||
r = rx.recv().unwrap();
|
||||
sum += r;
|
||||
println!("{}", r);
|
||||
r = rx.recv();
|
||||
r = rx.recv().unwrap();
|
||||
sum += r;
|
||||
println!("{}", r);
|
||||
r = rx.recv();
|
||||
r = rx.recv().unwrap();
|
||||
sum += r;
|
||||
println!("{}", r);
|
||||
r = rx.recv();
|
||||
r = rx.recv().unwrap();
|
||||
sum += r;
|
||||
println!("{}", r);
|
||||
tx.send(5);
|
||||
tx.send(6);
|
||||
tx.send(7);
|
||||
tx.send(8);
|
||||
r = rx.recv();
|
||||
tx.send(5).unwrap();
|
||||
tx.send(6).unwrap();
|
||||
tx.send(7).unwrap();
|
||||
tx.send(8).unwrap();
|
||||
r = rx.recv().unwrap();
|
||||
sum += r;
|
||||
println!("{}", r);
|
||||
r = rx.recv();
|
||||
r = rx.recv().unwrap();
|
||||
sum += r;
|
||||
println!("{}", r);
|
||||
r = rx.recv();
|
||||
r = rx.recv().unwrap();
|
||||
sum += r;
|
||||
println!("{}", r);
|
||||
r = rx.recv();
|
||||
r = rx.recv().unwrap();
|
||||
sum += r;
|
||||
println!("{}", r);
|
||||
assert_eq!(sum, 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8);
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
|
||||
pub fn main() { test00(); }
|
||||
|
||||
|
|
@ -18,8 +18,8 @@ fn test00() {
|
|||
let (tx, rx) = channel();
|
||||
let number_of_messages: int = 1000;
|
||||
let mut i: int = 0;
|
||||
while i < number_of_messages { tx.send(i + 0); i += 1; }
|
||||
while i < number_of_messages { tx.send(i + 0).unwrap(); i += 1; }
|
||||
i = 0;
|
||||
while i < number_of_messages { sum += rx.recv(); i += 1; }
|
||||
while i < number_of_messages { sum += rx.recv().unwrap(); i += 1; }
|
||||
assert_eq!(sum, number_of_messages * (number_of_messages - 1) / 2);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
#![allow(dead_assignment)]
|
||||
|
||||
use std::comm::channel;
|
||||
use std::sync::mpsc::channel;
|
||||
|
||||
pub fn main() { test00(); }
|
||||
|
||||
|
|
@ -25,21 +25,21 @@ fn test00() {
|
|||
let number_of_messages: int = 1000;
|
||||
let mut i: int = 0;
|
||||
while i < number_of_messages {
|
||||
tx0.send(i + 0);
|
||||
tx1.send(i + 0);
|
||||
tx2.send(i + 0);
|
||||
tx3.send(i + 0);
|
||||
tx0.send(i + 0).unwrap();
|
||||
tx1.send(i + 0).unwrap();
|
||||
tx2.send(i + 0).unwrap();
|
||||
tx3.send(i + 0).unwrap();
|
||||
i += 1;
|
||||
}
|
||||
i = 0;
|
||||
while i < number_of_messages {
|
||||
r = rx.recv();
|
||||
r = rx.recv().unwrap();
|
||||
sum += r;
|
||||
r = rx.recv();
|
||||
r = rx.recv().unwrap();
|
||||
sum += r;
|
||||
r = rx.recv();
|
||||
r = rx.recv().unwrap();
|
||||
sum += r;
|
||||
r = rx.recv();
|
||||
r = rx.recv().unwrap();
|
||||
sum += r;
|
||||
i += 1;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
#![allow(dead_assignment)]
|
||||
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
use std::task;
|
||||
|
||||
pub fn main() { test00(); }
|
||||
|
|
@ -18,7 +18,7 @@ pub fn main() { test00(); }
|
|||
fn test00_start(c: &Sender<int>, start: int,
|
||||
number_of_messages: int) {
|
||||
let mut i: int = 0;
|
||||
while i < number_of_messages { c.send(start + i); i += 1; }
|
||||
while i < number_of_messages { c.send(start + i).unwrap(); i += 1; }
|
||||
}
|
||||
|
||||
fn test00() {
|
||||
|
|
@ -46,13 +46,13 @@ fn test00() {
|
|||
|
||||
let mut i: int = 0;
|
||||
while i < number_of_messages {
|
||||
r = rx.recv();
|
||||
r = rx.recv().unwrap();
|
||||
sum += r;
|
||||
r = rx.recv();
|
||||
r = rx.recv().unwrap();
|
||||
sum += r;
|
||||
r = rx.recv();
|
||||
r = rx.recv().unwrap();
|
||||
sum += r;
|
||||
r = rx.recv();
|
||||
r = rx.recv().unwrap();
|
||||
sum += r;
|
||||
i += 1;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,13 +9,13 @@
|
|||
// except according to those terms.
|
||||
|
||||
use std::thread::Thread;
|
||||
use std::comm::{channel, Sender};
|
||||
use std::sync::mpsc::{channel, Sender};
|
||||
|
||||
pub fn main() { test00(); }
|
||||
|
||||
fn test00_start(c: &Sender<int>, number_of_messages: int) {
|
||||
let mut i: int = 0;
|
||||
while i < number_of_messages { c.send(i + 0); i += 1; }
|
||||
while i < number_of_messages { c.send(i + 0).unwrap(); i += 1; }
|
||||
}
|
||||
|
||||
fn test00() {
|
||||
|
|
@ -30,7 +30,7 @@ fn test00() {
|
|||
|
||||
let mut i: int = 0;
|
||||
while i < number_of_messages {
|
||||
sum += rx.recv();
|
||||
sum += rx.recv().unwrap();
|
||||
println!("{}", r);
|
||||
i += 1;
|
||||
}
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue