mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

std: Get stdtest all passing again

Browse source 
This commit brings the library up-to-date in order to get all tests passing
again
This commit is contained in:
Alex Crichton 2013-12-12 21:38:57 -08:00
parent d830fcc6eb
commit 018d60509c
29 changed files with 461 additions and 600 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
mk/host.mk
View file

@ -24,7 +24,7 @@ define CP_HOST_STAGE_N
# Note: $(3) and $(4) are both the same!
$$(HBIN$(2)_H_$(4))/rustc$$(X_$(4)): \
$$(TBIN$(1)_T_$(4)_H_$(3))/rustc$$(X_$(4))
$$(TBIN$(1)_T_$(4)_H_$(3))/rustc$$(X_$(4)) \
$$(HLIBRUSTC_DEFAULT$(2)_H_$(4)) \
| $$(HBIN$(2)_H_$(4))/
@$$(call E, cp: $$@)

4
mk/tests.mk
View file

@ -348,13 +348,13 @@ STDTESTDEP_$(1)_$(2)_$(3) =
endif
$(3)/stage$(1)/test/stdtest-$(2)$$(X_$(2)): \
$$(STDLIB_CRATE) $$(STDLIB_INPUTS) \
$$(STDLIB_CRATE) $$(STDLIB_INPUTS) \
$$(STDTESTDEP_$(1)_$(2)_$(3))
@$$(call E, compile_and_link: $$@)
$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
$(3)/stage$(1)/test/extratest-$(2)$$(X_$(2)): \
$$(EXTRALIB_CRATE) $$(EXTRALIB_INPUTS) \
$$(EXTRALIB_CRATE) $$(EXTRALIB_INPUTS) \
$$(STDTESTDEP_$(1)_$(2)_$(3))
@$$(call E, compile_and_link: $$@)
$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test

2
src/driver/driver.rs
View file

@ -8,6 +8,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#[cfg(stage0)] extern mod green;
#[cfg(rustpkg)]
extern mod this = "rustpkg";

2
src/libgreen/lib.rs
View file

@ -57,6 +57,8 @@ pub mod sleeper_list;
pub mod stack;
pub mod task;
#[cfg(test)] mod tests;
#[cfg(stage0)]
#[lang = "start"]
pub fn lang_start(main: *u8, argc: int, argv: **u8) -> int {

11
src/libnative/task.rs
View file

@ -22,7 +22,7 @@ use std::rt::task::{Task, BlockedTask};
use std::rt::thread::Thread;
use std::rt;
use std::sync::atomics::{AtomicUint, SeqCst, INIT_ATOMIC_UINT};
use std::task::TaskOpts;
use std::task::{TaskOpts, default_task_opts};
use std::unstable::mutex::{Mutex, MUTEX_INIT};
use std::unstable::stack;
@ -73,9 +73,14 @@ pub fn new() -> ~Task {
return task;
}
/// Spawns a function with the default configuration
pub fn spawn(f: proc()) {
spawn_opts(default_task_opts(), f)
}
/// Spawns a new task given the configuration options and a procedure to run
/// inside the task.
pub fn spawn(opts: TaskOpts, f: proc()) {
pub fn spawn_opts(opts: TaskOpts, f: proc()) {
// must happen before the spawn, no need to synchronize with a lock.
unsafe { THREAD_CNT.fetch_add(1, SeqCst); }
@ -238,7 +243,7 @@ impl rt::Runtime for Ops {
cur_task.put_runtime(self as ~rt::Runtime);
Local::put(cur_task);
task::spawn(opts, f);
task::spawn_opts(opts, f);
}
fn local_io<'a>(&'a mut self) -> Option<rtio::LocalIo<'a>> {

15
src/libstd/any.rs
View file

@ -119,7 +119,7 @@ impl<'a> AnyMutRefExt<'a> for &'a mut Any {
/// Extension methods for a owning `Any` trait object
pub trait AnyOwnExt {
/// Returns the boxed value if it is of type `T`, or
/// `None` if it isn't.
/// `Err(Self)` if it isn't.
fn move<T: 'static>(self) -> Result<~T, Self>;
}
@ -156,9 +156,8 @@ impl<'a> ToStr for &'a Any {
#[cfg(test)]
mod tests {
use prelude::*;
use super::*;
use super::AnyRefExt;
use option::{Some, None};
#[deriving(Eq)]
struct Test;
@ -385,8 +384,14 @@ mod tests {
let a = ~8u as ~Any;
let b = ~Test as ~Any;
assert_eq!(a.move(), Ok(~8u));
assert_eq!(b.move(), Ok(~Test));
match a.move::<uint>() {
Ok(a) => { assert_eq!(a, ~8u); }
Err(..) => fail!()
}
match b.move::<Test>() {
Ok(a) => { assert_eq!(a, ~Test); }
Err(..) => fail!()
}
let a = ~8u as ~Any;
let b = ~Test as ~Any;

430
src/libstd/comm/mod.rs
View file

@ -251,18 +251,21 @@ macro_rules! test (
mod $name {
#[allow(unused_imports)];
use util;
use super::super::*;
use native;
use prelude::*;
use super::*;
use super::super::*;
use task;
use util;
fn f() $b
$($a)* #[test] fn uv() { f() }
$($a)* #[test]
#[ignore(cfg(windows))] // FIXME(#11003)
fn native() {
use unstable::run_in_bare_thread;
run_in_bare_thread(f);
$($a)* #[test] fn native() {
use native;
let (p, c) = Chan::new();
do native::task::spawn { c.send(f()) }
p.recv();
}
}
)
@ -889,10 +892,16 @@ impl<T: Send> Drop for Port<T> {
mod test {
use prelude::*;
use task;
use rt::thread::Thread;
use native;
use os;
use super::*;
use rt::test::*;
pub fn stress_factor() -> uint {
match os::getenv("RUST_TEST_STRESS") {
Some(val) => from_str::<uint>(val).unwrap(),
None => 1,
}
}
test!(fn smoke() {
let (p, c) = Chan::new();
@ -919,99 +928,88 @@ mod test {
assert_eq!(p.recv(), 1);
})
#[test]
fn smoke_threads() {
test!(fn smoke_threads() {
let (p, c) = Chan::new();
do task::spawn_sched(task::SingleThreaded) {
do spawn {
c.send(1);
}
assert_eq!(p.recv(), 1);
}
})
#[test] #[should_fail]
fn smoke_port_gone() {
test!(fn smoke_port_gone() {
let (p, c) = Chan::new();
drop(p);
c.send(1);
}
} #[should_fail])
#[test] #[should_fail]
fn smoke_shared_port_gone() {
test!(fn smoke_shared_port_gone() {
let (p, c) = SharedChan::new();
drop(p);
c.send(1);
}
} #[should_fail])
#[test] #[should_fail]
fn smoke_shared_port_gone2() {
test!(fn smoke_shared_port_gone2() {
let (p, c) = SharedChan::new();
drop(p);
let c2 = c.clone();
drop(c);
c2.send(1);
}
} #[should_fail])
#[test] #[should_fail]
fn port_gone_concurrent() {
test!(fn port_gone_concurrent() {
let (p, c) = Chan::new();
do task::spawn_sched(task::SingleThreaded) {
do spawn {
p.recv();
}
loop { c.send(1) }
}
} #[should_fail])
#[test] #[should_fail]
fn port_gone_concurrent_shared() {
test!(fn port_gone_concurrent_shared() {
let (p, c) = SharedChan::new();
let c1 = c.clone();
do task::spawn_sched(task::SingleThreaded) {
do spawn {
p.recv();
}
loop {
c.send(1);
c1.send(1);
}
}
} #[should_fail])
#[test] #[should_fail]
fn smoke_chan_gone() {
test!(fn smoke_chan_gone() {
let (p, c) = Chan::<int>::new();
drop(c);
p.recv();
}
} #[should_fail])
#[test] #[should_fail]
fn smoke_chan_gone_shared() {
test!(fn smoke_chan_gone_shared() {
let (p, c) = SharedChan::<()>::new();
let c2 = c.clone();
drop(c);
drop(c2);
p.recv();
}
} #[should_fail])
#[test] #[should_fail]
fn chan_gone_concurrent() {
test!(fn chan_gone_concurrent() {
let (p, c) = Chan::new();
do task::spawn_sched(task::SingleThreaded) {
do spawn {
c.send(1);
c.send(1);
}
loop { p.recv(); }
}
} #[should_fail])
#[test]
fn stress() {
test!(fn stress() {
let (p, c) = Chan::new();
do task::spawn_sched(task::SingleThreaded) {
do spawn {
for _ in range(0, 10000) { c.send(1); }
}
for _ in range(0, 10000) {
assert_eq!(p.recv(), 1);
}
}
})
#[test]
fn stress_shared() {
test!(fn stress_shared() {
static AMT: uint = 10000;
static NTHREADS: uint = 8;
let (p, c) = SharedChan::<int>::new();
@ -1027,47 +1025,53 @@ mod test {
for _ in range(0, NTHREADS) {
let c = c.clone();
do task::spawn_sched(task::SingleThreaded) {
do spawn {
for _ in range(0, AMT) { c.send(1); }
}
}
p1.recv();
}
})
#[test]
#[ignore(cfg(windows))] // FIXME(#11003)
fn send_from_outside_runtime() {
let (p, c) = Chan::<int>::new();
let (p1, c1) = Chan::new();
let (port, chan) = SharedChan::new();
let chan2 = chan.clone();
do spawn {
c1.send(());
for _ in range(0, 40) {
assert_eq!(p.recv(), 1);
}
chan2.send(());
}
p1.recv();
let t = do Thread::start {
do native::task::spawn {
for _ in range(0, 40) {
c.send(1);
}
};
t.join();
chan.send(());
}
port.recv();
port.recv();
}
#[test]
#[ignore(cfg(windows))] // FIXME(#11003)
fn recv_from_outside_runtime() {
let (p, c) = Chan::<int>::new();
let t = do Thread::start {
let (dp, dc) = Chan::new();
do native::task::spawn {
for _ in range(0, 40) {
assert_eq!(p.recv(), 1);
}
dc.send(());
};
for _ in range(0, 40) {
c.send(1);
}
t.join();
dp.recv();
}
#[test]
@ -1075,173 +1079,132 @@ mod test {
fn no_runtime() {
let (p1, c1) = Chan::<int>::new();
let (p2, c2) = Chan::<int>::new();
let t1 = do Thread::start {
let (port, chan) = SharedChan::new();
let chan2 = chan.clone();
do native::task::spawn {
assert_eq!(p1.recv(), 1);
c2.send(2);
};
let t2 = do Thread::start {
chan2.send(());
}
do native::task::spawn {
c1.send(1);
assert_eq!(p2.recv(), 2);
};
t1.join();
t2.join();
}
#[test]
fn oneshot_single_thread_close_port_first() {
// Simple test of closing without sending
do run_in_newsched_task {
let (port, _chan) = Chan::<int>::new();
{ let _p = port; }
chan.send(());
}
port.recv();
port.recv();
}
#[test]
fn oneshot_single_thread_close_chan_first() {
test!(fn oneshot_single_thread_close_port_first() {
// Simple test of closing without sending
do run_in_newsched_task {
let (_port, chan) = Chan::<int>::new();
{ let _c = chan; }
}
}
let (port, _chan) = Chan::<int>::new();
{ let _p = port; }
})
#[test] #[should_fail]
fn oneshot_single_thread_send_port_close() {
test!(fn oneshot_single_thread_close_chan_first() {
// Simple test of closing without sending
let (_port, chan) = Chan::<int>::new();
{ let _c = chan; }
})
test!(fn oneshot_single_thread_send_port_close() {
// Testing that the sender cleans up the payload if receiver is closed
let (port, chan) = Chan::<~int>::new();
{ let _p = port; }
chan.send(~0);
}
} #[should_fail])
#[test]
fn oneshot_single_thread_recv_chan_close() {
test!(fn oneshot_single_thread_recv_chan_close() {
// Receiving on a closed chan will fail
do run_in_newsched_task {
let res = do spawntask_try {
let (port, chan) = Chan::<~int>::new();
{ let _c = chan; }
port.recv();
};
// What is our res?
assert!(res.is_err());
}
}
#[test]
fn oneshot_single_thread_send_then_recv() {
do run_in_newsched_task {
let res = do task::try {
let (port, chan) = Chan::<~int>::new();
chan.send(~10);
{ let _c = chan; }
port.recv();
};
// What is our res?
assert!(res.is_err());
})
test!(fn oneshot_single_thread_send_then_recv() {
let (port, chan) = Chan::<~int>::new();
chan.send(~10);
assert!(port.recv() == ~10);
})
test!(fn oneshot_single_thread_try_send_open() {
let (port, chan) = Chan::<int>::new();
assert!(chan.try_send(10));
assert!(port.recv() == 10);
})
test!(fn oneshot_single_thread_try_send_closed() {
let (port, chan) = Chan::<int>::new();
{ let _p = port; }
assert!(!chan.try_send(10));
})
test!(fn oneshot_single_thread_try_recv_open() {
let (port, chan) = Chan::<int>::new();
chan.send(10);
assert!(port.try_recv() == Some(10));
})
test!(fn oneshot_single_thread_try_recv_closed() {
let (port, chan) = Chan::<int>::new();
{ let _c = chan; }
assert!(port.recv_opt() == None);
})
test!(fn oneshot_single_thread_peek_data() {
let (port, chan) = Chan::<int>::new();
assert!(port.try_recv().is_none());
chan.send(10);
assert!(port.try_recv().is_some());
})
test!(fn oneshot_single_thread_peek_close() {
let (port, chan) = Chan::<int>::new();
{ let _c = chan; }
assert!(port.try_recv().is_none());
assert!(port.try_recv().is_none());
})
test!(fn oneshot_single_thread_peek_open() {
let (port, _) = Chan::<int>::new();
assert!(port.try_recv().is_none());
})
test!(fn oneshot_multi_task_recv_then_send() {
let (port, chan) = Chan::<~int>::new();
do spawn {
assert!(port.recv() == ~10);
}
}
#[test]
fn oneshot_single_thread_try_send_open() {
do run_in_newsched_task {
let (port, chan) = Chan::<int>::new();
assert!(chan.try_send(10));
assert!(port.recv() == 10);
chan.send(~10);
})
test!(fn oneshot_multi_task_recv_then_close() {
let (port, chan) = Chan::<~int>::new();
do spawn {
let _chan = chan;
}
}
let res = do task::try {
assert!(port.recv() == ~10);
};
assert!(res.is_err());
})
#[test]
fn oneshot_single_thread_try_send_closed() {
do run_in_newsched_task {
let (port, chan) = Chan::<int>::new();
{ let _p = port; }
assert!(!chan.try_send(10));
}
}
#[test]
fn oneshot_single_thread_try_recv_open() {
do run_in_newsched_task {
let (port, chan) = Chan::<int>::new();
chan.send(10);
assert!(port.try_recv() == Some(10));
}
}
#[test]
fn oneshot_single_thread_try_recv_closed() {
do run_in_newsched_task {
let (port, chan) = Chan::<int>::new();
{ let _c = chan; }
assert!(port.recv_opt() == None);
}
}
#[test]
fn oneshot_single_thread_peek_data() {
do run_in_newsched_task {
let (port, chan) = Chan::<int>::new();
assert!(port.try_recv().is_none());
chan.send(10);
assert!(port.try_recv().is_some());
}
}
#[test]
fn oneshot_single_thread_peek_close() {
do run_in_newsched_task {
let (port, chan) = Chan::<int>::new();
{ let _c = chan; }
assert!(port.try_recv().is_none());
assert!(port.try_recv().is_none());
}
}
#[test]
fn oneshot_single_thread_peek_open() {
do run_in_newsched_task {
let (port, _) = Chan::<int>::new();
assert!(port.try_recv().is_none());
}
}
#[test]
fn oneshot_multi_task_recv_then_send() {
do run_in_newsched_task {
let (port, chan) = Chan::<~int>::new();
do spawntask {
assert!(port.recv() == ~10);
}
chan.send(~10);
}
}
#[test]
fn oneshot_multi_task_recv_then_close() {
do run_in_newsched_task {
let (port, chan) = Chan::<~int>::new();
do spawntask_later {
let _chan = chan;
}
let res = do spawntask_try {
assert!(port.recv() == ~10);
};
assert!(res.is_err());
}
}
#[test]
fn oneshot_multi_thread_close_stress() {
test!(fn oneshot_multi_thread_close_stress() {
stress_factor().times(|| {
do run_in_newsched_task {
let (port, chan) = Chan::<int>::new();
let thread = do spawntask_thread {
let _p = port;
};
let _chan = chan;
thread.join();
let (port, chan) = Chan::<int>::new();
do spawn {
let _p = port;
}
let _chan = chan;
})
}
})
#[test]
fn oneshot_multi_thread_send_close_stress() {
test!(fn oneshot_multi_thread_send_close_stress() {
stress_factor().times(|| {
let (port, chan) = Chan::<int>::new();
do spawn {
@ -1251,10 +1214,9 @@ mod test {
chan.send(1);
};
})
}
})
#[test]
fn oneshot_multi_thread_recv_close_stress() {
test!(fn oneshot_multi_thread_recv_close_stress() {
stress_factor().times(|| {
let (port, chan) = Chan::<int>::new();
do spawn {
@ -1271,10 +1233,9 @@ mod test {
}
};
})
}
})
#[test]
fn oneshot_multi_thread_send_recv_stress() {
test!(fn oneshot_multi_thread_send_recv_stress() {
stress_factor().times(|| {
let (port, chan) = Chan::<~int>::new();
do spawn {
@ -1284,10 +1245,9 @@ mod test {
assert!(port.recv() == ~10);
}
})
}
})
#[test]
fn stream_send_recv_stress() {
test!(fn stream_send_recv_stress() {
stress_factor().times(|| {
let (port, chan) = Chan::<~int>::new();
@ -1297,7 +1257,7 @@ mod test {
fn send(chan: Chan<~int>, i: int) {
if i == 10 { return }
do spawntask_random {
do spawn {
chan.send(~i);
send(chan, i + 1);
}
@ -1306,44 +1266,37 @@ mod test {
fn recv(port: Port<~int>, i: int) {
if i == 10 { return }
do spawntask_random {
do spawn {
assert!(port.recv() == ~i);
recv(port, i + 1);
};
}
})
}
})
#[test]
fn recv_a_lot() {
test!(fn recv_a_lot() {
// Regression test that we don't run out of stack in scheduler context
do run_in_newsched_task {
let (port, chan) = Chan::new();
10000.times(|| { chan.send(()) });
10000.times(|| { port.recv() });
}
}
let (port, chan) = Chan::new();
10000.times(|| { chan.send(()) });
10000.times(|| { port.recv() });
})
#[test]
fn shared_chan_stress() {
do run_in_mt_newsched_task {
let (port, chan) = SharedChan::new();
let total = stress_factor() + 100;
total.times(|| {
let chan_clone = chan.clone();
do spawntask_random {
chan_clone.send(());
}
});
test!(fn shared_chan_stress() {
let (port, chan) = SharedChan::new();
let total = stress_factor() + 100;
total.times(|| {
let chan_clone = chan.clone();
do spawn {
chan_clone.send(());
}
});
total.times(|| {
port.recv();
});
}
}
total.times(|| {
port.recv();
});
})
#[test]
fn test_nested_recv_iter() {
test!(fn test_nested_recv_iter() {
let (port, chan) = Chan::<int>::new();
let (total_port, total_chan) = Chan::<int>::new();
@ -1360,10 +1313,9 @@ mod test {
chan.send(2);
drop(chan);
assert_eq!(total_port.recv(), 6);
}
})
#[test]
fn test_recv_iter_break() {
test!(fn test_recv_iter_break() {
let (port, chan) = Chan::<int>::new();
let (count_port, count_chan) = Chan::<int>::new();
@ -1385,5 +1337,5 @@ mod test {
chan.try_send(2);
drop(chan);
assert_eq!(count_port.recv(), 4);
}
})
}

94
src/libstd/comm/select.rs
View file

@ -51,11 +51,11 @@ use ops::Drop;
use option::{Some, None, Option};
use ptr::RawPtr;
use result::{Ok, Err};
use rt::thread::Thread;
use rt::local::Local;
use rt::task::Task;
use super::{Packet, Port};
use sync::atomics::{Relaxed, SeqCst};
use task;
use uint;
macro_rules! select {
@ -310,6 +310,7 @@ impl Iterator<*mut Packet> for PacketIterator {
}
#[cfg(test)]
#[allow(unused_imports)]
mod test {
use super::super::*;
use prelude::*;
@ -365,19 +366,16 @@ mod test {
)
})
#[test]
fn unblocks() {
use std::io::timer;
test!(fn unblocks() {
let (mut p1, c1) = Chan::<int>::new();
let (mut p2, _c2) = Chan::<int>::new();
let (p3, c3) = Chan::<int>::new();
do spawn {
timer::sleep(3);
20.times(task::deschedule);
c1.send(1);
p3.recv();
timer::sleep(3);
20.times(task::deschedule);
}
select! (
@ -389,18 +387,15 @@ mod test {
a = p1.recv_opt() => { assert_eq!(a, None); },
_b = p2.recv() => { fail!() }
)
}
#[test]
fn both_ready() {
use std::io::timer;
})
test!(fn both_ready() {
let (mut p1, c1) = Chan::<int>::new();
let (mut p2, c2) = Chan::<int>::new();
let (p3, c3) = Chan::<()>::new();
do spawn {
timer::sleep(3);
20.times(task::deschedule);
c1.send(1);
c2.send(2);
p3.recv();
@ -414,11 +409,12 @@ mod test {
a = p1.recv() => { assert_eq!(a, 1); },
a = p2.recv() => { assert_eq!(a, 2); }
)
assert_eq!(p1.try_recv(), None);
assert_eq!(p2.try_recv(), None);
c3.send(());
}
})
#[test]
fn stress() {
test!(fn stress() {
static AMT: int = 10000;
let (mut p1, c1) = Chan::<int>::new();
let (mut p2, c2) = Chan::<int>::new();
@ -442,69 +438,5 @@ mod test {
)
c3.send(());
}
}
#[test]
#[ignore(cfg(windows))] // FIXME(#11003)
fn stress_native() {
use std::rt::thread::Thread;
use std::unstable::run_in_bare_thread;
static AMT: int = 10000;
do run_in_bare_thread {
let (mut p1, c1) = Chan::<int>::new();
let (mut p2, c2) = Chan::<int>::new();
let (p3, c3) = Chan::<()>::new();
let t = do Thread::start {
for i in range(0, AMT) {
if i % 2 == 0 {
c1.send(i);
} else {
c2.send(i);
}
p3.recv();
}
};
for i in range(0, AMT) {
select! (
i1 = p1.recv() => { assert!(i % 2 == 0 && i == i1); },
i2 = p2.recv() => { assert!(i % 2 == 1 && i == i2); }
)
c3.send(());
}
t.join();
}
}
#[test]
#[ignore(cfg(windows))] // FIXME(#11003)
fn native_both_ready() {
use std::rt::thread::Thread;
use std::unstable::run_in_bare_thread;
do run_in_bare_thread {
let (mut p1, c1) = Chan::<int>::new();
let (mut p2, c2) = Chan::<int>::new();
let (p3, c3) = Chan::<()>::new();
let t = do Thread::start {
c1.send(1);
c2.send(2);
p3.recv();
};
select! (
a = p1.recv() => { assert_eq!(a, 1); },
b = p2.recv() => { assert_eq!(b, 2); }
)
select! (
a = p1.recv() => { assert_eq!(a, 1); },
b = p2.recv() => { assert_eq!(b, 2); }
)
c3.send(());
t.join();
}
}
})
}

87
src/libstd/io/fs.rs
View file

@ -714,7 +714,7 @@ mod test {
}
}
fn tmpdir() -> TempDir {
pub fn tmpdir() -> TempDir {
use os;
use rand;
let ret = os::tmpdir().join(format!("rust-{}", rand::random::<u32>()));
@ -722,32 +722,7 @@ mod test {
TempDir(ret)
}
macro_rules! test (
{ fn $name:ident() $b:block } => (
mod $name {
use prelude::*;
use io::{SeekSet, SeekCur, SeekEnd, io_error, Read, Open,
ReadWrite};
use io;
use str;
use io::fs::{File, rmdir, mkdir, readdir, rmdir_recursive,
mkdir_recursive, copy, unlink, stat, symlink, link,
readlink, chmod, lstat, change_file_times};
use io::fs::test::tmpdir;
use util;
fn f() $b
#[test] fn uv() { f() }
#[test] fn native() {
use rt::test::run_in_newsched_task;
run_in_newsched_task(f);
}
}
)
)
test!(fn file_test_io_smoke_test() {
iotest!(fn file_test_io_smoke_test() {
let message = "it's alright. have a good time";
let tmpdir = tmpdir();
let filename = &tmpdir.join("file_rt_io_file_test.txt");
@ -767,7 +742,7 @@ mod test {
unlink(filename);
})
test!(fn invalid_path_raises() {
iotest!(fn invalid_path_raises() {
let tmpdir = tmpdir();
let filename = &tmpdir.join("file_that_does_not_exist.txt");
let mut called = false;
@ -780,7 +755,7 @@ mod test {
assert!(called);
})
test!(fn file_test_iounlinking_invalid_path_should_raise_condition() {
iotest!(fn file_test_iounlinking_invalid_path_should_raise_condition() {
let tmpdir = tmpdir();
let filename = &tmpdir.join("file_another_file_that_does_not_exist.txt");
let mut called = false;
@ -790,7 +765,7 @@ mod test {
assert!(called);
})
test!(fn file_test_io_non_positional_read() {
iotest!(fn file_test_io_non_positional_read() {
let message: &str = "ten-four";
let mut read_mem = [0, .. 8];
let tmpdir = tmpdir();
@ -815,7 +790,7 @@ mod test {
assert_eq!(read_str, message);
})
test!(fn file_test_io_seek_and_tell_smoke_test() {
iotest!(fn file_test_io_seek_and_tell_smoke_test() {
let message = "ten-four";
let mut read_mem = [0, .. 4];
let set_cursor = 4 as u64;
@ -841,7 +816,7 @@ mod test {
assert_eq!(tell_pos_post_read, message.len() as u64);
})
test!(fn file_test_io_seek_and_write() {
iotest!(fn file_test_io_seek_and_write() {
let initial_msg = "food-is-yummy";
let overwrite_msg = "-the-bar!!";
let final_msg = "foo-the-bar!!";
@ -864,7 +839,7 @@ mod test {
assert!(read_str == final_msg.to_owned());
})
test!(fn file_test_io_seek_shakedown() {
iotest!(fn file_test_io_seek_shakedown() {
use std::str; // 01234567890123
let initial_msg = "qwer-asdf-zxcv";
let chunk_one: &str = "qwer";
@ -895,7 +870,7 @@ mod test {
unlink(filename);
})
test!(fn file_test_stat_is_correct_on_is_file() {
iotest!(fn file_test_stat_is_correct_on_is_file() {
let tmpdir = tmpdir();
let filename = &tmpdir.join("file_stat_correct_on_is_file.txt");
{
@ -908,7 +883,7 @@ mod test {
unlink(filename);
})
test!(fn file_test_stat_is_correct_on_is_dir() {
iotest!(fn file_test_stat_is_correct_on_is_dir() {
let tmpdir = tmpdir();
let filename = &tmpdir.join("file_stat_correct_on_is_dir");
mkdir(filename, io::UserRWX);
@ -917,7 +892,7 @@ mod test {
rmdir(filename);
})
test!(fn file_test_fileinfo_false_when_checking_is_file_on_a_directory() {
iotest!(fn file_test_fileinfo_false_when_checking_is_file_on_a_directory() {
let tmpdir = tmpdir();
let dir = &tmpdir.join("fileinfo_false_on_dir");
mkdir(dir, io::UserRWX);
@ -925,7 +900,7 @@ mod test {
rmdir(dir);
})
test!(fn file_test_fileinfo_check_exists_before_and_after_file_creation() {
iotest!(fn file_test_fileinfo_check_exists_before_and_after_file_creation() {
let tmpdir = tmpdir();
let file = &tmpdir.join("fileinfo_check_exists_b_and_a.txt");
File::create(file).write(bytes!("foo"));
@ -934,7 +909,7 @@ mod test {
assert!(!file.exists());
})
test!(fn file_test_directoryinfo_check_exists_before_and_after_mkdir() {
iotest!(fn file_test_directoryinfo_check_exists_before_and_after_mkdir() {
let tmpdir = tmpdir();
let dir = &tmpdir.join("before_and_after_dir");
assert!(!dir.exists());
@ -945,7 +920,7 @@ mod test {
assert!(!dir.exists());
})
test!(fn file_test_directoryinfo_readdir() {
iotest!(fn file_test_directoryinfo_readdir() {
use std::str;
let tmpdir = tmpdir();
let dir = &tmpdir.join("di_readdir");
@ -976,11 +951,11 @@ mod test {
rmdir(dir);
})
test!(fn recursive_mkdir_slash() {
iotest!(fn recursive_mkdir_slash() {
mkdir_recursive(&Path::new("/"), io::UserRWX);
})
test!(fn unicode_path_is_dir() {
iotest!(fn unicode_path_is_dir() {
assert!(Path::new(".").is_dir());
assert!(!Path::new("test/stdtest/fs.rs").is_dir());
@ -998,7 +973,7 @@ mod test {
assert!(filepath.exists());
})
test!(fn unicode_path_exists() {
iotest!(fn unicode_path_exists() {
assert!(Path::new(".").exists());
assert!(!Path::new("test/nonexistent-bogus-path").exists());
@ -1010,7 +985,7 @@ mod test {
assert!(!Path::new("test/unicode-bogus-path-각丁ー再见").exists());
})
test!(fn copy_file_does_not_exist() {
iotest!(fn copy_file_does_not_exist() {
let from = Path::new("test/nonexistent-bogus-path");
let to = Path::new("test/other-bogus-path");
match io::result(|| copy(&from, &to)) {
@ -1022,7 +997,7 @@ mod test {
}
})
test!(fn copy_file_ok() {
iotest!(fn copy_file_ok() {
let tmpdir = tmpdir();
let input = tmpdir.join("in.txt");
let out = tmpdir.join("out.txt");
@ -1035,7 +1010,7 @@ mod test {
assert_eq!(input.stat().perm, out.stat().perm);
})
test!(fn copy_file_dst_dir() {
iotest!(fn copy_file_dst_dir() {
let tmpdir = tmpdir();
let out = tmpdir.join("out");
@ -1045,7 +1020,7 @@ mod test {
}
})
test!(fn copy_file_dst_exists() {
iotest!(fn copy_file_dst_exists() {
let tmpdir = tmpdir();
let input = tmpdir.join("in");
let output = tmpdir.join("out");
@ -1058,7 +1033,7 @@ mod test {
(bytes!("foo")).to_owned());
})
test!(fn copy_file_src_dir() {
iotest!(fn copy_file_src_dir() {
let tmpdir = tmpdir();
let out = tmpdir.join("out");
@ -1068,7 +1043,7 @@ mod test {
assert!(!out.exists());
})
test!(fn copy_file_preserves_perm_bits() {
iotest!(fn copy_file_preserves_perm_bits() {
let tmpdir = tmpdir();
let input = tmpdir.join("in.txt");
let out = tmpdir.join("out.txt");
@ -1083,7 +1058,7 @@ mod test {
})
#[cfg(not(windows))] // FIXME(#10264) operation not permitted?
test!(fn symlinks_work() {
iotest!(fn symlinks_work() {
let tmpdir = tmpdir();
let input = tmpdir.join("in.txt");
let out = tmpdir.join("out.txt");
@ -1098,14 +1073,14 @@ mod test {
})
#[cfg(not(windows))] // apparently windows doesn't like symlinks
test!(fn symlink_noexist() {
iotest!(fn symlink_noexist() {
let tmpdir = tmpdir();
// symlinks can point to things that don't exist
symlink(&tmpdir.join("foo"), &tmpdir.join("bar"));
assert!(readlink(&tmpdir.join("bar")).unwrap() == tmpdir.join("foo"));
})
test!(fn readlink_not_symlink() {
iotest!(fn readlink_not_symlink() {
let tmpdir = tmpdir();
match io::result(|| readlink(&*tmpdir)) {
Ok(..) => fail!("wanted a failure"),
@ -1113,7 +1088,7 @@ mod test {
}
})
test!(fn links_work() {
iotest!(fn links_work() {
let tmpdir = tmpdir();
let input = tmpdir.join("in.txt");
let out = tmpdir.join("out.txt");
@ -1139,7 +1114,7 @@ mod test {
}
})
test!(fn chmod_works() {
iotest!(fn chmod_works() {
let tmpdir = tmpdir();
let file = tmpdir.join("in.txt");
@ -1156,7 +1131,7 @@ mod test {
chmod(&file, io::UserFile);
})
test!(fn sync_doesnt_kill_anything() {
iotest!(fn sync_doesnt_kill_anything() {
let tmpdir = tmpdir();
let path = tmpdir.join("in.txt");
@ -1169,7 +1144,7 @@ mod test {
drop(file);
})
test!(fn truncate_works() {
iotest!(fn truncate_works() {
let tmpdir = tmpdir();
let path = tmpdir.join("in.txt");
@ -1200,7 +1175,7 @@ mod test {
drop(file);
})
test!(fn open_flavors() {
iotest!(fn open_flavors() {
let tmpdir = tmpdir();
match io::result(|| File::open_mode(&tmpdir.join("a"), io::Open,

4
src/libstd/io/mod.rs
View file

@ -313,6 +313,10 @@ pub use self::net::udp::UdpStream;
pub use self::pipe::PipeStream;
pub use self::process::Process;
/// Testing helpers
#[cfg(test)]
mod test;
/// Synchronous, non-blocking filesystem operations.
pub mod fs;

62
src/libstd/io/net/tcp.rs
View file

@ -176,7 +176,7 @@ mod test {
#[test]
fn smoke_test_ip4() {
let addr = next_test_ip4();
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
port.recv();
@ -195,7 +195,7 @@ mod test {
#[test]
fn smoke_test_ip6() {
let addr = next_test_ip6();
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
port.recv();
@ -214,7 +214,7 @@ mod test {
#[test]
fn read_eof_ip4() {
let addr = next_test_ip4();
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
port.recv();
@ -233,7 +233,7 @@ mod test {
#[test]
fn read_eof_ip6() {
let addr = next_test_ip6();
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
port.recv();
@ -252,10 +252,10 @@ mod test {
#[test]
fn read_eof_twice_ip4() {
let addr = next_test_ip4();
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
port.take().recv();
port.recv();
let _stream = TcpStream::connect(addr);
// Close
}
@ -281,7 +281,7 @@ mod test {
#[test]
fn read_eof_twice_ip6() {
let addr = next_test_ip6();
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
port.recv();
@ -310,7 +310,7 @@ mod test {
#[test]
fn write_close_ip4() {
let addr = next_test_ip4();
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
port.recv();
@ -342,7 +342,7 @@ mod test {
#[test]
fn write_close_ip6() {
let addr = next_test_ip6();
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
port.recv();
@ -375,7 +375,7 @@ mod test {
fn multiple_connect_serial_ip4() {
let addr = next_test_ip4();
let max = 10;
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
port.recv();
@ -398,7 +398,7 @@ mod test {
fn multiple_connect_serial_ip6() {
let addr = next_test_ip6();
let max = 10;
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
port.recv();
@ -421,16 +421,15 @@ mod test {
fn multiple_connect_interleaved_greedy_schedule_ip4() {
let addr = next_test_ip4();
static MAX: int = 10;
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
let stream = Cell::new(stream);
// Start another task to handle the connection
do spawn {
let mut stream = stream.take();
let mut stream = stream;
let mut buf = [0];
stream.read(buf);
assert!(buf[0] == i as u8);
@ -460,15 +459,15 @@ mod test {
fn multiple_connect_interleaved_greedy_schedule_ip6() {
let addr = next_test_ip6();
static MAX: int = 10;
let (port, chan) = oneshot();
let (port, chan) = Chan::<()>::new();
do spawn {
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
let stream = Cell::new(stream);
// Start another task to handle the connection
do spawn {
let mut stream = stream.take();
let mut stream = stream;
let mut buf = [0];
stream.read(buf);
assert!(buf[0] == i as u8);
@ -498,16 +497,15 @@ mod test {
fn multiple_connect_interleaved_lazy_schedule_ip4() {
let addr = next_test_ip4();
static MAX: int = 10;
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
for stream in acceptor.incoming().take(MAX as uint) {
let stream = Cell::new(stream);
// Start another task to handle the connection
do spawn {
let mut stream = stream.take();
let mut stream = stream;
let mut buf = [0];
stream.read(buf);
assert!(buf[0] == 99);
@ -536,16 +534,15 @@ mod test {
fn multiple_connect_interleaved_lazy_schedule_ip6() {
let addr = next_test_ip6();
static MAX: int = 10;
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
let mut acceptor = TcpListener::bind(addr).listen();
chan.send(());
for stream in acceptor.incoming().take(MAX as uint) {
let stream = Cell::new(stream);
// Start another task to handle the connection
do spawn {
let mut stream = stream.take();
let mut stream = stream;
let mut buf = [0];
stream.read(buf);
assert!(buf[0] == 99);
@ -573,23 +570,18 @@ mod test {
#[cfg(test)]
fn socket_name(addr: SocketAddr) {
do run_in_mt_newsched_task {
do spawntask {
let mut listener = TcpListener::bind(addr).unwrap();
let mut listener = TcpListener::bind(addr).unwrap();
// Make sure socket_name gives
// us the socket we binded to.
let so_name = listener.socket_name();
assert!(so_name.is_some());
assert_eq!(addr, so_name.unwrap());
}
}
// Make sure socket_name gives
// us the socket we binded to.
let so_name = listener.socket_name();
assert!(so_name.is_some());
assert_eq!(addr, so_name.unwrap());
}
#[cfg(test)]
fn peer_name(addr: SocketAddr) {
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
let mut acceptor = TcpListener::bind(addr).listen();

11
src/libstd/io/net/udp.rs
View file

@ -101,6 +101,7 @@ mod test {
use super::*;
use io::net::ip::{Ipv4Addr, SocketAddr};
use io::*;
use io::test::*;
use prelude::*;
#[test] #[ignore]
@ -121,7 +122,7 @@ mod test {
fn socket_smoke_test_ip4() {
let server_ip = next_test_ip4();
let client_ip = next_test_ip4();
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
match UdpSocket::bind(client_ip) {
@ -154,7 +155,7 @@ mod test {
fn socket_smoke_test_ip6() {
let server_ip = next_test_ip6();
let client_ip = next_test_ip6();
let (port, chan) = oneshot();
let (port, chan) = Chan::<()>::new();
do spawn {
match UdpSocket::bind(client_ip) {
@ -168,7 +169,7 @@ mod test {
match UdpSocket::bind(server_ip) {
Some(ref mut server) => {
chan.take().send(());
chan.send(());
let mut buf = [0];
match server.recvfrom(buf) {
Some((nread, src)) => {
@ -187,7 +188,7 @@ mod test {
fn stream_smoke_test_ip4() {
let server_ip = next_test_ip4();
let client_ip = next_test_ip4();
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
match UdpSocket::bind(client_ip) {
@ -223,7 +224,7 @@ mod test {
fn stream_smoke_test_ip6() {
let server_ip = next_test_ip6();
let client_ip = next_test_ip6();
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
match UdpSocket::bind(client_ip) {

5
src/libstd/io/net/unix.rs
View file

@ -141,11 +141,12 @@ mod tests {
use prelude::*;
use super::*;
use io::*;
use io::test::*;
fn smalltest(server: proc(UnixStream), client: proc(UnixStream)) {
let path1 = next_test_unix();
let path2 = path1.clone();
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
port.recv();
@ -229,7 +230,7 @@ mod tests {
let times = 10;
let path1 = next_test_unix();
let path2 = path1.clone();
let (port, chan) = oneshot();
let (port, chan) = Chan::new();
do spawn {
port.recv();

17
src/libstd/io/stdio.rs
View file

@ -308,23 +308,10 @@ impl Writer for StdWriter {
#[cfg(test)]
mod tests {
use super::*;
use rt::test::run_in_newsched_task;
#[test]
fn smoke_uv() {
iotest!(fn smoke() {
// Just make sure we can acquire handles
stdin();
stdout();
stderr();
}
#[test]
fn smoke_native() {
do run_in_newsched_task {
stdin();
stdout();
stderr();
}
}
})
}

44
src/libstd/io/test.rs
View file

@ -8,9 +8,48 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#[macro_escape];
use os;
use prelude::*;
use rand;
use rand::Rng;
use std::io::net::ip::*;
use sync::atomics::{AtomicUint, INIT_ATOMIC_UINT, Relaxed};
macro_rules! iotest (
{ fn $name:ident() $b:block } => (
mod $name {
#[allow(unused_imports)];
use super::super::*;
use super::*;
use io;
use prelude::*;
use io::*;
use io::fs::*;
use io::net::tcp::*;
use io::net::ip::*;
use io::net::udp::*;
use io::net::unix::*;
use str;
use util;
fn f() $b
#[test] fn green() { f() }
#[test] fn native() {
use native;
let (p, c) = Chan::new();
do native::task::spawn { c.send(f()) }
p.recv();
}
}
)
)
/// Get a port number, starting at 9600, for use in tests
pub fn next_test_port() -> u16 {
use unstable::atomics::{AtomicUint, INIT_ATOMIC_UINT, Relaxed};
static mut next_offset: AtomicUint = INIT_ATOMIC_UINT;
unsafe {
base_port() + next_offset.fetch_add(1, Relaxed) as u16
@ -44,9 +83,6 @@ all want to use ports. This function figures out which workspace
it is running in and assigns a port range based on it.
*/
fn base_port() -> u16 {
use os;
use str::StrSlice;
use vec::ImmutableVector;
let base = 9600u16;
let range = 1000u16;

8
src/libstd/lib.rs
View file

@ -65,13 +65,15 @@
// When testing libstd, bring in libuv as the I/O backend so tests can print
// things and all of the std::io tests have an I/O interface to run on top
// of
#[cfg(test)] extern mod rustuv = "rustuv#0.9-pre";
#[cfg(test)] extern mod rustuv = "rustuv";
#[cfg(test)] extern mod native = "native";
#[cfg(test)] extern mod green = "green";
// Make extra accessible for benchmarking
#[cfg(test)] extern mod extra = "extra#0.9-pre";
#[cfg(test)] extern mod extra = "extra";
// Make std testable by not duplicating lang items. See #2912
#[cfg(test)] extern mod realstd = "std#0.9-pre";
#[cfg(test)] extern mod realstd = "std";
#[cfg(test)] pub use kinds = realstd::kinds;
#[cfg(test)] pub use ops = realstd::ops;
#[cfg(test)] pub use cmp = realstd::cmp;

1
src/libstd/local_data.rs
View file

@ -432,6 +432,7 @@ mod tests {
}
#[test]
#[allow(dead_code)]
fn test_tls_overwrite_multiple_types() {
static str_key: Key<~str> = &Key;
static box_key: Key<@()> = &Key;

19
src/libstd/rt/local.rs
View file

@ -49,7 +49,6 @@ impl Local<local_ptr::Borrowed<Task>> for Task {
mod test {
use option::None;
use unstable::run_in_bare_thread;
use rt::test::*;
use super::*;
use rt::task::Task;
use rt::local_ptr;
@ -58,8 +57,7 @@ mod test {
fn thread_local_task_smoke_test() {
do run_in_bare_thread {
local_ptr::init();
let mut sched = ~new_test_uv_sched();
let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
let task = ~Task::new();
Local::put(task);
let task: ~Task = Local::take();
cleanup_task(task);
@ -70,12 +68,11 @@ mod test {
fn thread_local_task_two_instances() {
do run_in_bare_thread {
local_ptr::init();
let mut sched = ~new_test_uv_sched();
let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
let task = ~Task::new();
Local::put(task);
let task: ~Task = Local::take();
cleanup_task(task);
let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
let task = ~Task::new();
Local::put(task);
let task: ~Task = Local::take();
cleanup_task(task);
@ -87,8 +84,7 @@ mod test {
fn borrow_smoke_test() {
do run_in_bare_thread {
local_ptr::init();
let mut sched = ~new_test_uv_sched();
let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
let task = ~Task::new();
Local::put(task);
unsafe {
@ -103,8 +99,7 @@ mod test {
fn borrow_with_return() {
do run_in_bare_thread {
local_ptr::init();
let mut sched = ~new_test_uv_sched();
let task = ~Task::new_root(&mut sched.stack_pool, None, proc(){});
let task = ~Task::new();
Local::put(task);
{
@ -116,5 +111,9 @@ mod test {
}
}
fn cleanup_task(mut t: ~Task) {
t.destroyed = true;
}
}

96
src/libstd/rt/task.rs
View file

@ -176,8 +176,12 @@ impl Task {
// Cleanup the dynamic borrowck debugging info
borrowck::clear_task_borrow_list();
// TODO: dox
unsafe {
let me: *mut Task = Local::unsafe_borrow();
(*me).death.collect_failure((*me).unwinder.result());
}
let mut me: ~Task = Local::take();
me.death.collect_failure(me.unwinder.result());
me.destroyed = true;
return me;
}
@ -375,92 +379,76 @@ impl Drop for Death {
#[cfg(test)]
mod test {
use super::*;
use rt::test::*;
use prelude::*;
use task;
#[test]
fn local_heap() {
do run_in_newsched_task() {
let a = @5;
let b = a;
assert!(*a == 5);
assert!(*b == 5);
}
let a = @5;
let b = a;
assert!(*a == 5);
assert!(*b == 5);
}
#[test]
fn tls() {
use local_data;
do run_in_newsched_task() {
local_data_key!(key: @~str)
local_data::set(key, @~"data");
assert!(*local_data::get(key, |k| k.map(|k| *k)).unwrap() == ~"data");
local_data_key!(key2: @~str)
local_data::set(key2, @~"data");
assert!(*local_data::get(key2, |k| k.map(|k| *k)).unwrap() == ~"data");
}
local_data_key!(key: @~str)
local_data::set(key, @~"data");
assert!(*local_data::get(key, |k| k.map(|k| *k)).unwrap() == ~"data");
local_data_key!(key2: @~str)
local_data::set(key2, @~"data");
assert!(*local_data::get(key2, |k| k.map(|k| *k)).unwrap() == ~"data");
}
#[test]
fn unwind() {
do run_in_newsched_task() {
let result = spawntask_try(proc()());
rtdebug!("trying first assert");
assert!(result.is_ok());
let result = spawntask_try(proc() fail!());
rtdebug!("trying second assert");
assert!(result.is_err());
}
let result = task::try(proc()());
rtdebug!("trying first assert");
assert!(result.is_ok());
let result = task::try::<()>(proc() fail!());
rtdebug!("trying second assert");
assert!(result.is_err());
}
#[test]
fn rng() {
do run_in_uv_task() {
use rand::{rng, Rng};
let mut r = rng();
let _ = r.next_u32();
}
use rand::{rng, Rng};
let mut r = rng();
let _ = r.next_u32();
}
#[test]
fn logging() {
do run_in_uv_task() {
info!("here i am. logging in a newsched task");
}
info!("here i am. logging in a newsched task");
}
#[test]
fn comm_stream() {
do run_in_newsched_task() {
let (port, chan) = Chan::new();
chan.send(10);
assert!(port.recv() == 10);
}
let (port, chan) = Chan::new();
chan.send(10);
assert!(port.recv() == 10);
}
#[test]
fn comm_shared_chan() {
do run_in_newsched_task() {
let (port, chan) = SharedChan::new();
chan.send(10);
assert!(port.recv() == 10);
}
let (port, chan) = SharedChan::new();
chan.send(10);
assert!(port.recv() == 10);
}
#[test]
fn heap_cycles() {
use option::{Option, Some, None};
do run_in_newsched_task {
struct List {
next: Option<@mut List>,
}
let a = @mut List { next: None };
let b = @mut List { next: Some(a) };
a.next = Some(b);
struct List {
next: Option<@mut List>,
}
let a = @mut List { next: None };
let b = @mut List { next: Some(a) };
a.next = Some(b);
}
#[test]
@ -471,8 +459,8 @@ mod test {
#[test]
fn block_and_wake() {
do with_test_task |task| {
BlockedTask::block(task).wake().unwrap()
}
let task = ~Task::new();
let mut task = BlockedTask::block(task).wake().unwrap();
task.destroyed = true;
}
}

4
src/libstd/run.rs
View file

@ -426,13 +426,13 @@ mod tests {
}
fn writeclose(fd: c_int, s: &str) {
let mut writer = PipeStream::open(fd as int);
let mut writer = PipeStream::open(fd);
writer.write(s.as_bytes());
}
fn readclose(fd: c_int) -> ~str {
let mut res = ~[];
let mut reader = PipeStream::open(fd as int);
let mut reader = PipeStream::open(fd);
let mut buf = [0, ..1024];
loop {
match reader.read(buf) {

1
src/libstd/sync/arc.rs
View file

@ -131,7 +131,6 @@ impl<T> Drop for UnsafeArc<T>{
mod tests {
use prelude::*;
use super::UnsafeArc;
use task;
use mem::size_of;
#[test]

12
src/libstd/sync/mpmc_bounded_queue.rs
View file

@ -163,8 +163,8 @@ impl<T: Send> Clone for Queue<T> {
mod tests {
use prelude::*;
use option::*;
use task;
use super::Queue;
use native;
#[test]
fn test() {
@ -172,14 +172,17 @@ mod tests {
let nmsgs = 1000u;
let mut q = Queue::with_capacity(nthreads*nmsgs);
assert_eq!(None, q.pop());
let (port, chan) = SharedChan::new();
for _ in range(0, nthreads) {
let q = q.clone();
do task::spawn_sched(task::SingleThreaded) {
let chan = chan.clone();
do native::task::spawn {
let mut q = q;
for i in range(0, nmsgs) {
assert!(q.push(i));
}
chan.send(());
}
}
@ -188,7 +191,7 @@ mod tests {
let (completion_port, completion_chan) = Chan::new();
completion_ports.push(completion_port);
let q = q.clone();
do task::spawn_sched(task::SingleThreaded) {
do native::task::spawn {
let mut q = q;
let mut i = 0u;
loop {
@ -207,5 +210,8 @@ mod tests {
for completion_port in completion_ports.mut_iter() {
assert_eq!(nmsgs, completion_port.recv());
}
for _ in range(0, nthreads) {
port.recv();
}
}
}

10
src/libstd/sync/mpsc_queue.rs
View file

@ -203,8 +203,8 @@ impl<T: Send, P: Send> Consumer<T, P> {
mod tests {
use prelude::*;
use task;
use super::{queue, Data, Empty, Inconsistent};
use native;
#[test]
fn test_full() {
@ -222,14 +222,17 @@ mod tests {
Empty => {}
Inconsistent | Data(..) => fail!()
}
let (port, chan) = SharedChan::new();
for _ in range(0, nthreads) {
let q = p.clone();
do task::spawn_sched(task::SingleThreaded) {
let chan = chan.clone();
do native::task::spawn {
let mut q = q;
for i in range(0, nmsgs) {
q.push(i);
}
chan.send(());
}
}
@ -240,6 +243,9 @@ mod tests {
Data(_) => { i += 1 }
}
}
for _ in range(0, nthreads) {
port.recv();
}
}
}

7
src/libstd/sync/spsc_queue.rs
View file

@ -268,7 +268,7 @@ impl<T: Send, P: Send> Drop for State<T, P> {
mod test {
use prelude::*;
use super::queue;
use task;
use native;
#[test]
fn smoke() {
@ -314,7 +314,8 @@ mod test {
fn stress_bound(bound: uint) {
let (c, mut p) = queue(bound, ());
do task::spawn_sched(task::SingleThreaded) {
let (port, chan) = Chan::new();
do native::task::spawn {
let mut c = c;
for _ in range(0, 100000) {
loop {
@ -325,10 +326,12 @@ mod test {
}
}
}
chan.send(());
}
for _ in range(0, 100000) {
p.push(1);
}
port.recv();
}
}
}

98
src/libstd/task.rs
View file

@ -64,6 +64,7 @@ use send_str::{SendStr, IntoSendStr};
use str::Str;
use util;
#[cfg(test)] use any::{AnyOwnExt, AnyRefExt};
#[cfg(test)] use comm::SharedChan;
#[cfg(test)] use ptr;
#[cfg(test)] use result;
@ -385,59 +386,43 @@ pub fn failing() -> bool {
#[test]
fn test_unnamed_task() {
use rt::test::run_in_uv_task;
do run_in_uv_task {
do spawn {
with_task_name(|name| {
assert!(name.is_none());
})
}
do spawn {
with_task_name(|name| {
assert!(name.is_none());
})
}
}
#[test]
fn test_owned_named_task() {
use rt::test::run_in_uv_task;
do run_in_uv_task {
let mut t = task();
t.name(~"ada lovelace");
do t.spawn {
with_task_name(|name| {
assert!(name.unwrap() == "ada lovelace");
})
}
let mut t = task();
t.name(~"ada lovelace");
do t.spawn {
with_task_name(|name| {
assert!(name.unwrap() == "ada lovelace");
})
}
}
#[test]
fn test_static_named_task() {
use rt::test::run_in_uv_task;
do run_in_uv_task {
let mut t = task();
t.name("ada lovelace");
do t.spawn {
with_task_name(|name| {
assert!(name.unwrap() == "ada lovelace");
})
}
let mut t = task();
t.name("ada lovelace");
do t.spawn {
with_task_name(|name| {
assert!(name.unwrap() == "ada lovelace");
})
}
}
#[test]
fn test_send_named_task() {
use rt::test::run_in_uv_task;
do run_in_uv_task {
let mut t = task();
t.name("ada lovelace".into_send_str());
do t.spawn {
with_task_name(|name| {
assert!(name.unwrap() == "ada lovelace");
})
}
let mut t = task();
t.name("ada lovelace".into_send_str());
do t.spawn {
with_task_name(|name| {
assert!(name.unwrap() == "ada lovelace");
})
}
}
@ -508,28 +493,19 @@ fn test_try_fail() {
}
}
#[cfg(test)]
fn get_sched_id() -> int {
use rt::sched::Scheduler;
let mut sched = Local::borrow(None::<Scheduler>);
sched.get().sched_id() as int
}
#[test]
fn test_spawn_sched() {
use clone::Clone;
let (po, ch) = SharedChan::new();
fn f(i: int, ch: SharedChan<()>) {
let parent_sched_id = get_sched_id();
do spawn_sched(SingleThreaded) {
let child_sched_id = get_sched_id();
assert!(parent_sched_id != child_sched_id);
let ch = ch.clone();
do spawn {
if (i == 0) {
ch.send(());
} else {
f(i - 1, ch.clone());
f(i - 1, ch);
}
};
@ -542,16 +518,9 @@ fn test_spawn_sched() {
fn test_spawn_sched_childs_on_default_sched() {
let (po, ch) = Chan::new();
// Assuming tests run on the default scheduler
let default_id = get_sched_id();
do spawn_sched(SingleThreaded) {
do spawn {
let ch = ch;
let parent_sched_id = get_sched_id();
do spawn {
let child_sched_id = get_sched_id();
assert!(parent_sched_id != child_sched_id);
assert_eq!(child_sched_id, default_id);
ch.send(());
};
};
@ -562,6 +531,7 @@ fn test_spawn_sched_childs_on_default_sched() {
#[test]
fn test_spawn_sched_blocking() {
use unstable::mutex::Mutex;
use num::Times;
unsafe {
@ -574,7 +544,7 @@ fn test_spawn_sched_blocking() {
let mut lock = Mutex::new();
let lock2 = lock.clone();
do spawn_sched(SingleThreaded) {
do spawn {
let mut lock = lock2;
lock.lock();
@ -681,11 +651,7 @@ fn test_child_doesnt_ref_parent() {
#[test]
fn test_simple_newsched_spawn() {
use rt::test::run_in_uv_task;
do run_in_uv_task {
spawn(proc()())
}
spawn(proc()())
}
#[test]

2
src/libstd/unstable/mutex.rs
View file

@ -333,12 +333,12 @@ mod test {
fn somke_cond() {
static mut lock: Mutex = MUTEX_INIT;
unsafe {
lock.lock();
let t = do Thread::start {
lock.lock();
lock.signal();
lock.unlock();
};
lock.lock();
lock.wait();
lock.unlock();
t.join();

9
src/libstd/unstable/stack.rs
View file

@ -24,11 +24,6 @@
//! detection is not guaranteed to continue in the future. Usage of this module
//! is discouraged unless absolutely necessary.
use rt::task::Task;
use option::None;
use rt::local::Local;
use unstable::intrinsics;
static RED_ZONE: uint = 20 * 1024;
/// This function is invoked from rust's current __morestack function. Segmented
@ -41,6 +36,10 @@ static RED_ZONE: uint = 20 * 1024;
// irrelevant for documentation purposes.
#[cfg(not(test))] // in testing, use the original libstd's version
pub extern "C" fn rust_stack_exhausted() {
use rt::task::Task;
use option::None;
use rt::local::Local;
use unstable::intrinsics;
unsafe {
// We're calling this function because the stack just ran out. We need

3
src/libstd/unstable/sync.rs
View file

@ -161,9 +161,8 @@ impl<T:Send> Exclusive<T> {
mod tests {
use option::*;
use prelude::*;
use super::{Exclusive, UnsafeArc, atomic};
use super::Exclusive;
use task;
use mem::size_of;
#[test]
fn exclusive_new_arc() {

1
src/libstd/vec.rs
View file

@ -2874,7 +2874,6 @@ impl<A> Extendable<A> for ~[A] {
#[cfg(test)]
mod tests {
use option::{None, Some};
use mem;
use vec::*;
use cmp::*;