user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove all i suffixes

Browse source
This commit is contained in:
Tobias Bucher 2015-01-25 22:05:03 +01:00
parent 52c74e63da
commit 7f64fe4e27
474 changed files with 1999 additions and 1999 deletions
Download patch file Download diff file Expand all files Collapse all files

46
src/libstd/sync/mpsc/mod.rs
View file

@ -59,9 +59,9 @@
//! // Create a simple streaming channel
//! let (tx, rx) = channel();
//! Thread::spawn(move|| {
//! tx.send(10i).unwrap();
//! tx.send(10).unwrap();
//! });
//! assert_eq!(rx.recv().unwrap(), 10i);
//! assert_eq!(rx.recv().unwrap(), 10);
//! ```
//!
//! Shared usage:
@ -74,14 +74,14 @@
//! // where tx is the sending half (tx for transmission), and rx is the receiving
//! // half (rx for receiving).
//! let (tx, rx) = channel();
//! for i in 0i..10i {
//! for i in 0..10 {
//! let tx = tx.clone();
//! Thread::spawn(move|| {
//! tx.send(i).unwrap();
//! });
//! }
//!
//! for _ in 0i..10i {
//! for _ in 0..10 {
//! let j = rx.recv().unwrap();
//! assert!(0 <= j && j < 10);
//! }
@ -514,15 +514,15 @@ pub fn channel<T: Send>() -> (Sender<T>, Receiver<T>) {
/// let (tx, rx) = sync_channel(1);
///
/// // this returns immediately
/// tx.send(1i).unwrap();
/// tx.send(1).unwrap();
///
/// Thread::spawn(move|| {
/// // this will block until the previous message has been received
/// tx.send(2i).unwrap();
/// tx.send(2).unwrap();
/// });
///
/// assert_eq!(rx.recv().unwrap(), 1i);
/// assert_eq!(rx.recv().unwrap(), 2i);
/// assert_eq!(rx.recv().unwrap(), 1);
/// assert_eq!(rx.recv().unwrap(), 2);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn sync_channel<T: Send>(bound: uint) -> (SyncSender<T>, Receiver<T>) {
@ -562,11 +562,11 @@ impl<T: Send> Sender<T> {
/// let (tx, rx) = channel();
///
/// // This send is always successful
/// tx.send(1i).unwrap();
/// tx.send(1).unwrap();
///
/// // This send will fail because the receiver is gone
/// drop(rx);
/// assert_eq!(tx.send(1i).err().unwrap().0, 1);
/// assert_eq!(tx.send(1).err().unwrap().0, 1);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn send(&self, t: T) -> Result<(), SendError<T>> {
@ -1045,7 +1045,7 @@ mod test {
#[test]
fn drop_full() {
let (tx, _rx) = channel();
tx.send(box 1i).unwrap();
tx.send(box 1).unwrap();
}
#[test]
@ -1053,7 +1053,7 @@ mod test {
let (tx, _rx) = channel();
drop(tx.clone());
drop(tx.clone());
tx.send(box 1i).unwrap();
tx.send(box 1).unwrap();
}
#[test]
@ -1147,7 +1147,7 @@ mod test {
fn stress() {
let (tx, rx) = channel::<int>();
let t = Thread::scoped(move|| {
for _ in 0u..10000 { tx.send(1i).unwrap(); }
for _ in 0u..10000 { tx.send(1).unwrap(); }
});
for _ in 0u..10000 {
assert_eq!(rx.recv().unwrap(), 1);
@ -1187,13 +1187,13 @@ mod test {
let (tx2, rx2) = channel::<int>();
let t1 = Thread::scoped(move|| {
tx1.send(()).unwrap();
for _ in 0i..40 {
for _ in 0..40 {
assert_eq!(rx2.recv().unwrap(), 1);
}
});
rx1.recv().unwrap();
let t2 = Thread::scoped(move|| {
for _ in 0i..40 {
for _ in 0..40 {
tx2.send(1).unwrap();
}
});
@ -1205,7 +1205,7 @@ mod test {
fn recv_from_outside_runtime() {
let (tx, rx) = channel::<int>();
let t = Thread::scoped(move|| {
for _ in 0i..40 {
for _ in 0..40 {
assert_eq!(rx.recv().unwrap(), 1);
}
});
@ -1391,9 +1391,9 @@ mod test {
for _ in 0..stress_factor() {
let (tx, rx) = channel();
let _t = Thread::spawn(move|| {
tx.send(box 10i).unwrap();
tx.send(box 10).unwrap();
});
assert!(rx.recv().unwrap() == box 10i);
assert!(rx.recv().unwrap() == box 10);
}
}
@ -1429,8 +1429,8 @@ mod test {
fn recv_a_lot() {
// Regression test that we don't run out of stack in scheduler context
let (tx, rx) = channel();
for _ in 0i..10000 { tx.send(()).unwrap(); }
for _ in 0i..10000 { rx.recv().unwrap(); }
for _ in 0..10000 { tx.send(()).unwrap(); }
for _ in 0..10000 { rx.recv().unwrap(); }
}
#[test]
@ -1567,7 +1567,7 @@ mod sync_tests {
#[test]
fn drop_full() {
let (tx, _rx) = sync_channel(1);
tx.send(box 1i).unwrap();
tx.send(box 1).unwrap();
}
#[test]
@ -1855,9 +1855,9 @@ mod sync_tests {
for _ in 0..stress_factor() {
let (tx, rx) = sync_channel::<Box<int>>(0);
let _t = Thread::spawn(move|| {
tx.send(box 10i).unwrap();
tx.send(box 10).unwrap();
});
assert!(rx.recv().unwrap() == box 10i);
assert!(rx.recv().unwrap() == box 10);
}
}

4
src/libstd/sync/mpsc/mpsc_queue.rs
View file

@ -165,8 +165,8 @@ mod tests {
#[test]
fn test_full() {
let q = Queue::new();
q.push(box 1i);
q.push(box 2i);
q.push(box 1);
q.push(box 2);
}
#[test]

8
src/libstd/sync/mpsc/select.rs
View file

@ -32,15 +32,15 @@
//! let (tx1, rx1) = channel();
//! let (tx2, rx2) = channel();
//!
//! tx1.send(1i).unwrap();
//! tx2.send(2i).unwrap();
//! tx1.send(1).unwrap();
//! tx2.send(2).unwrap();
//!
//! select! {
//! val = rx1.recv() => {
//! assert_eq!(val.unwrap(), 1i);
//! assert_eq!(val.unwrap(), 1);
//! },
//! val = rx2.recv() => {
//! assert_eq!(val.unwrap(), 2i);
//! assert_eq!(val.unwrap(), 2);
//! }
//! }
//! ```

16
src/libstd/sync/mpsc/spsc_queue.rs
View file

@ -253,9 +253,9 @@ mod test {
fn smoke() {
unsafe {
let queue = Queue::new(0);
queue.push(1i);
queue.push(1);
queue.push(2);
assert_eq!(queue.pop(), Some(1i));
assert_eq!(queue.pop(), Some(1));
assert_eq!(queue.pop(), Some(2));
assert_eq!(queue.pop(), None);
queue.push(3);
@ -270,7 +270,7 @@ mod test {
fn peek() {
unsafe {
let queue = Queue::new(0);
queue.push(vec![1i]);
queue.push(vec![1]);
// Ensure the borrowchecker works
match queue.peek() {
@ -290,8 +290,8 @@ mod test {
fn drop_full() {
unsafe {
let q = Queue::new(0);
q.push(box 1i);
q.push(box 2i);
q.push(box 1);
q.push(box 2);
}
}
@ -299,7 +299,7 @@ mod test {
fn smoke_bound() {
unsafe {
let q = Queue::new(0);
q.push(1i);
q.push(1);
q.push(2);
assert_eq!(q.pop(), Some(1));
assert_eq!(q.pop(), Some(2));
@ -328,7 +328,7 @@ mod test {
for _ in 0u..100000 {
loop {
match q2.pop() {
Some(1i) => break,
Some(1) => break,
Some(_) => panic!(),
None => {}
}
@ -336,7 +336,7 @@ mod test {
}
tx.send(()).unwrap();
});
for _ in 0i..100000 {
for _ in 0..100000 {
q.push(1);
}
rx.recv().unwrap();