#![crate_type = "bin"]
#![feature(phase)]
-// we use our own (green) start below; do not link in libnative; issue #13247.
-#![no_start]
-
#![deny(warnings)]
extern crate test;
extern crate getopts;
-extern crate green;
-extern crate rustuv;
#[phase(plugin, link)] extern crate log;
extern crate regex;
pub mod common;
pub mod errors;
-#[start]
-fn start(argc: int, argv: *const *const u8) -> int {
- green::start(argc, argv, rustuv::event_loop, main)
-}
-
pub fn main() {
let args = os::args();
let config = parse_config(args);
`rustuv::event_loop`. All tasks will have no I/O support, but they will still be
able to deschedule/reschedule (use channels, locks, etc).
-~~~{.rust}
+~~~{.ignore}
extern crate green;
extern crate rustuv;
//! > **Note**: This `main` function in this example does *not* have I/O
//! > support. The basic event loop does not provide any support
//!
-//! # Starting with I/O support in libgreen
-//!
-//! ```rust
-//! extern crate green;
-//! extern crate rustuv;
-//!
-//! #[start]
-//! fn start(argc: int, argv: *const *const u8) -> int {
-//! green::start(argc, argv, rustuv::event_loop, main)
-//! }
-//!
-//! fn main() {
-//! // this code is running in a pool of schedulers all powered by libuv
-//! }
-//! ```
-//!
-//! The above code can also be shortened with a macro from libgreen.
-//!
-//! ```
-//! #![feature(phase)]
-//! #[phase(plugin)] extern crate green;
-//!
-//! green_start!(main)
-//!
-//! fn main() {
-//! // run inside of a green pool
-//! }
-//! ```
-//!
//! # Using a scheduler pool
//!
//! This library adds a `GreenTaskBuilder` trait that extends the methods
//!
//! ```rust
//! extern crate green;
-//! extern crate rustuv;
//!
//! # fn main() {
//! use std::task::TaskBuilder;
//!
//! let mut config = PoolConfig::new();
//!
-//! // Optional: Set the event loop to be rustuv's to allow I/O to work
-//! config.event_loop_factory = rustuv::event_loop;
-//!
//! let mut pool = SchedPool::new(config);
//!
//! // Spawn tasks into the pool of schedulers
#![allow(deprecated)]
#[cfg(test)] #[phase(plugin, link)] extern crate log;
-#[cfg(test)] extern crate rustuv;
extern crate libc;
extern crate alloc;
pub mod stack;
pub mod task;
-/// A helper macro for booting a program with libgreen
-///
-/// # Example
-///
-/// ```
-/// #![feature(phase)]
-/// #[phase(plugin)] extern crate green;
-///
-/// green_start!(main)
-///
-/// fn main() {
-/// // running with libgreen
-/// }
-/// ```
-#[macro_export]
-macro_rules! green_start( ($f:ident) => (
- mod __start {
- extern crate green;
- extern crate rustuv;
-
- #[start]
- fn start(argc: int, argv: *const *const u8) -> int {
- green::start(argc, argv, rustuv::event_loop, super::$f)
- }
- }
-) )
-
/// Set up a default runtime configuration, given compiler-supplied arguments.
///
/// This function will block until the entire pool of M:N schedulers have
#[cfg(test)]
mod test {
- use rustuv;
-
use std::rt::task::TaskOpts;
use std::rt::task::Task;
use std::rt::local::Local;
// }
//}
- #[test]
- fn test_io_callback() {
- use std::io::timer;
-
- let mut pool = SchedPool::new(PoolConfig {
- threads: 2,
- event_loop_factory: rustuv::event_loop,
- });
-
- // This is a regression test that when there are no schedulable tasks in
- // the work queue, but we are performing I/O, that once we do put
- // something in the work queue again the scheduler picks it up and
- // doesn't exit before emptying the work queue
- pool.spawn(TaskOpts::new(), proc() {
- spawn(proc() {
- timer::sleep(Duration::milliseconds(10));
- });
- });
-
- pool.shutdown();
- }
-
#[test]
fn wakeup_across_scheds() {
let (tx1, rx1) = channel();
fn spawn_opts(opts: TaskOpts, f: proc():Send) {
let mut pool = SchedPool::new(PoolConfig {
threads: 1,
- event_loop_factory: ::rustuv::event_loop,
+ event_loop_factory: super::super::basic::event_loop,
});
pool.spawn(opts, f);
pool.shutdown();
#![reexport_test_harness_main = "test_main"]
-// 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 crate rustuv;
-#[cfg(test)] extern crate native;
#[cfg(test)] extern crate green;
#[cfg(test)] extern crate debug;
#[cfg(test)] #[phase(plugin, link)] extern crate log;
pub use core_sync::comm;
-// Run tests with libgreen instead of libnative.
-#[cfg(test)] #[start]
-fn start(argc: int, argv: *const *const u8) -> int {
- green::start(argc, argv, rustuv::event_loop, test_main)
-}
-
/* Exported macros */
pub mod macros;
#![no_start]
extern crate green;
-extern crate rustuv;
use std::task::spawn;
use std::os;
#[start]
fn start(argc: int, argv: *const *const u8) -> int {
- green::start(argc, argv, rustuv::event_loop, main)
+ green::start(argc, argv, green::basic::event_loop, main)
}
fn main() {
// no-pretty-expanded
-#![feature(phase)]
-#[phase(plugin)] extern crate green;
-
use std::string::String;
use std::fmt;
-green_start!(main)
-
fn print_complements() {
let all = [Blue, Red, Yellow];
for aa in all.iter() {
// no-pretty-expanded FIXME #15189
-#![feature(phase)]
-#[phase(plugin)] extern crate green;
-
use std::sync::Arc;
-green_start!(main)
-
//
// Utilities.
//
// no-pretty-expanded FIXME #15189
-#![feature(phase)]
#![allow(non_snake_case)]
-#[phase(plugin)] extern crate green;
use std::from_str::FromStr;
use std::iter::count;
use std::os;
use std::sync::{Arc, RWLock};
-green_start!(main)
-
fn A(i: uint, j: uint) -> f64 {
((i + j) * (i + j + 1) / 2 + i + 1) as f64
}
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
-#![feature(phase)]
-#[phase(plugin)] extern crate green;
-green_start!(main)
-
fn start(n_tasks: int, token: int) {
let (tx, mut rx) = channel();
tx.send(token);
// except according to those terms.
// This is (hopefully) a quick test to get a good idea about spawning
-// performance in libgreen. Note that this uses the rustuv event loop rather
-// than the basic event loop in order to get a better real world idea about the
-// performance of a task spawn.
+// performance in libgreen.
extern crate green;
-extern crate rustuv;
#[start]
fn start(argc: int, argv: *const *const u8) -> int {
- green::start(argc, argv, rustuv::event_loop, main)
+ green::start(argc, argv, green::basic::event_loop, main)
}
fn main() {
+++ /dev/null
--include ../tools.mk
-
-HOST_LIB_DIR=$(TMPDIR)/../../../stage$(RUST_BUILD_STAGE)/lib
-# This overrides the LD_LIBRARY_PATH for RUN
-TARGET_RPATH_DIR:=$(TARGET_RPATH_DIR):$(TMPDIR)
-
-all:
- $(RUSTC) lib.rs
- $(CC) main.c -o $(call RUN_BINFILE,main) $(call RPATH_LINK_SEARCH,$(HOST_LIB_DIR)) -lboot
- $(call RUN,main)
- $(call REMOVE_DYLIBS,boot)
- $(call FAIL,main)
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![crate_name="boot"]
-#![crate_type="dylib"]
-
-extern crate rustuv;
-extern crate green;
-
-#[no_mangle] // this needs to get called from C
-pub extern "C" fn foo(argc: int, argv: *const *const u8) -> int {
- green::start(argc, argv, rustuv::event_loop, proc() {
- spawn(proc() {
- println!("hello");
- });
- })
-}
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// this is the rust entry point that we're going to call.
-int foo(int argc, char *argv[]);
-
-int main(int argc, char *argv[]) {
- return foo(argc, argv);
-}
extern crate libc;
extern crate native;
-extern crate green;
-extern crate rustuv;
-use std::io::{Process, Command};
+use std::io::{Process, Command, timer};
use std::time::Duration;
+use libc;
+use std::str;
+
macro_rules! succeed( ($e:expr) => (
match $e { Ok(..) => {}, Err(e) => fail!("failure: {}", e) }
) )
-macro_rules! iotest (
- { fn $name:ident() $b:block $($a:attr)* } => (
- mod $name {
- #![allow(unused_imports)]
-
- use std::io::timer;
- use libc;
- use std::str;
- use std::io::process::Command;
- use native;
- use super::{sleeper, test_destroy_actually_kills};
-
- fn f() $b
-
- $($a)* #[test] fn green() { f() }
- $($a)* #[test] fn native() {
- use native;
- let (tx, rx) = channel();
- native::task::spawn(proc() { tx.send(f()) });
- rx.recv();
- }
- }
- )
-)
-
-#[cfg(test)] #[start]
-fn start(argc: int, argv: *const *const u8) -> int {
- green::start(argc, argv, rustuv::event_loop, test_main)
-}
-
-iotest!(fn test_destroy_once() {
+fn test_destroy_once() {
let mut p = sleeper();
match p.signal_exit() {
Ok(()) => {}
Err(e) => fail!("error: {}", e),
}
-})
+}
#[cfg(unix)]
pub fn sleeper() -> Process {
Command::new("ping").arg("127.0.0.1").arg("-n").arg("1000").spawn().unwrap()
}
-iotest!(fn test_destroy_twice() {
+fn test_destroy_twice() {
let mut p = sleeper();
succeed!(p.signal_exit()); // this shouldnt crash...
let _ = p.signal_exit(); // ...and nor should this (and nor should the destructor)
-})
+}
pub fn test_destroy_actually_kills(force: bool) {
use std::io::process::{Command, ProcessOutput, ExitStatus, ExitSignal};
}
}
-iotest!(fn test_unforced_destroy_actually_kills() {
+fn test_unforced_destroy_actually_kills() {
test_destroy_actually_kills(false);
-})
+}
-iotest!(fn test_forced_destroy_actually_kills() {
+fn test_forced_destroy_actually_kills() {
test_destroy_actually_kills(true);
-})
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
-extern crate native;
-extern crate green;
-extern crate rustuv;
-
use std::time::Duration;
-#[start]
-fn start(argc: int, argv: *const *const u8) -> int {
- green::start(argc, argv, rustuv::event_loop, main)
-}
-
fn main() {
native::task::spawn(proc() customtask());
}
// ignore-fast
-extern crate green;
-extern crate rustuv;
-extern crate native;
-
use std::os;
use std::io;
use std::str;
-#[start]
-fn start(argc: int, argv: *const *const u8) -> int {
- green::start(argc, argv, rustuv::event_loop, main)
-}
-
fn main() {
let args = os::args();
let args = args.as_slice();
if args.len() > 1 && args[1].as_slice() == "child" {
- if args[2].as_slice() == "green" {
- child();
- } else {
- let (tx, rx) = channel();
- native::task::spawn(proc() { tx.send(child()); });
- rx.recv();
- }
+ child();
} else {
- parent("green".to_string());
- parent("native".to_string());
- let (tx, rx) = channel();
- native::task::spawn(proc() {
- parent("green".to_string());
- parent("native".to_string());
- tx.send(());
- });
- rx.recv();
+ parent();
}
}
-fn parent(flavor: String) {
+fn parent() {
let args = os::args();
let args = args.as_slice();
let mut p = io::process::Command::new(args[0].as_slice())
- .arg("child").arg(flavor).spawn().unwrap();
+ .arg("child").spawn().unwrap();
p.stdin.get_mut_ref().write_str("test1\ntest2\ntest3").unwrap();
let out = p.wait_with_output().unwrap();
assert!(out.status.success());
// This test may not always fail, but it can be flaky if the race it used to
// expose is still present.
-extern crate green;
-extern crate rustuv;
-extern crate native;
-
-#[start]
-fn start(argc: int, argv: *const *const u8) -> int {
- green::start(argc, argv, rustuv::event_loop, main)
-}
-
fn helper(rx: Receiver<Sender<()>>) {
for tx in rx.iter() {
let _ = tx.send_opt(());
}
}
-fn test() {
+fn main() {
let (tx, rx) = channel();
spawn(proc() { helper(rx) });
let (snd, rcv) = channel::<int>();
}
}
}
-
-fn main() {
- let (tx, rx) = channel();
- spawn(proc() {
- tx.send(test());
- });
- rx.recv();
-
- let (tx, rx) = channel();
- native::task::spawn(proc() {
- tx.send(test());
- });
- rx.recv();
-}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(phase)]
-
-#[phase(plugin, link)]
-extern crate green;
-extern crate native;
use std::io::process;
use std::io::Command;
use std::io;
use std::os;
-green_start!(main)
-
fn main() {
let args = os::args();
if args.len() > 1 && args.get(1).as_slice() == "child" {
test();
- let (tx, rx) = channel();
- native::task::spawn(proc() {
- tx.send(test());
- });
- rx.recv();
-
}
fn child() {
.spawn().unwrap();
assert!(p.wait().unwrap().success());
}
-
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(phase)]
-extern crate native;
-#[phase(plugin)]
-extern crate green;
-
-use native::NativeTaskBuilder;
use std::io::{TempDir, Command, fs};
use std::os;
use std::task::TaskBuilder;
-green_start!(main)
-
fn main() {
// If we're the child, make sure we were invoked correctly
let args = os::args();
}
test();
- let (tx, rx) = channel();
- TaskBuilder::new().native().spawn(proc() {
- tx.send(test());
- });
- rx.recv();
}
fn test() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(phase)]
-#[phase(plugin)]
-extern crate green;
-extern crate native;
-
-use native::NativeTaskBuilder;
use std::io::{process, Command};
use std::os;
-use std::task::TaskBuilder;
-
-green_start!(main)
fn main() {
let len = os::args().len();
if len == 1 {
test();
- let (tx, rx) = channel();
- TaskBuilder::new().native().spawn(proc() {
- tx.send(test());
- });
- rx.recv();
} else {
assert_eq!(len, 3);
}
// Note that the first thing we do is put ourselves in our own process group so
// we don't interfere with other running tests.
-extern crate green;
-extern crate rustuv;
extern crate libc;
use std::io::process;
use std::io::process::Command;
use std::io::signal::{Listener, Interrupt};
-#[start]
-fn start(argc: int, argv: *const *const u8) -> int {
- green::start(argc, argv, rustuv::event_loop, main)
-}
-
fn main() {
unsafe { libc::setsid(); }
// quite quickly and it takes a few seconds for the sockets to get
// recycled.
-#![feature(phase)]
-
-#[phase(plugin)]
-extern crate green;
-extern crate native;
-
use std::io::{TcpListener, Listener, Acceptor, EndOfFile, TcpStream};
use std::sync::{atomic, Arc};
-use std::task::TaskBuilder;
-use native::NativeTaskBuilder;
static N: uint = 8;
static M: uint = 20;
-green_start!(main)
-
fn main() {
test();
-
- let (tx, rx) = channel();
- TaskBuilder::new().native().spawn(proc() {
- tx.send(test());
- });
- rx.recv();
}
fn test() {
// Everything should have been accepted.
assert_eq!(cnt.load(atomic::SeqCst), N * M);
}
-
#![allow(experimental)]
#![reexport_test_harness_main = "test_main"]
-extern crate native;
-extern crate green;
-extern crate rustuv;
+#![allow(unused_imports)]
-#[cfg(test)] #[start]
-fn start(argc: int, argv: *const *const u8) -> int {
- green::start(argc, argv, rustuv::event_loop, test_main)
-}
-
-macro_rules! iotest (
- { fn $name:ident() $b:block $(#[$a:meta])* } => (
- mod $name {
- #![allow(unused_imports)]
-
- use std::io::*;
- use std::io::net::tcp::*;
- use std::io::test::*;
- use std::io;
- use std::time::Duration;
-
- fn f() $b
+use std::io::*;
+use std::io::net::tcp::*;
+use std::io::test::*;
+use std::io;
+use std::time::Duration;
- $(#[$a])* #[test] fn green() { f() }
- $(#[$a])* #[test] fn native() {
- use native;
- let (tx, rx) = channel();
- native::task::spawn(proc() { tx.send(f()) });
- rx.recv();
- }
- }
- )
-)
-
-iotest!(fn eventual_timeout() {
+#[cfg_attr(target_os = "freebsd", ignore)]
+fn eventual_timeout() {
use native;
let addr = next_test_ip4();
let host = addr.ip.to_string();
}
}
fail!("never timed out!");
-} #[cfg_attr(target_os = "freebsd", ignore)])
+}
-iotest!(fn timeout_success() {
+fn timeout_success() {
let addr = next_test_ip4();
let host = addr.ip.to_string();
let port = addr.port;
let _l = TcpListener::bind(host.as_slice(), port).unwrap().listen();
assert!(TcpStream::connect_timeout(addr, Duration::milliseconds(1000)).is_ok());
-})
+}
-iotest!(fn timeout_error() {
+fn timeout_error() {
let addr = next_test_ip4();
assert!(TcpStream::connect_timeout(addr, Duration::milliseconds(1000)).is_err());
-})
-
- iotest!(fn connect_timeout_zero() {
- let addr = next_test_ip4();
- assert!(TcpStream::connect_timeout(addr, Duration::milliseconds(0)).is_err());
- })
+}
- iotest!(fn connect_timeout_negative() {
- let addr = next_test_ip4();
- assert!(TcpStream::connect_timeout(addr, Duration::milliseconds(-1)).is_err());
- })
+fn connect_timeout_zero() {
+ let addr = next_test_ip4();
+ assert!(TcpStream::connect_timeout(addr, Duration::milliseconds(0)).is_err());
+}
+fn connect_timeout_negative() {
+ let addr = next_test_ip4();
+ assert!(TcpStream::connect_timeout(addr, Duration::milliseconds(-1)).is_err());
+}
#[phase(plugin, link)]
extern crate log;
extern crate libc;
-extern crate green;
-extern crate rustuv;
extern crate debug;
use std::io::net::tcp::{TcpListener, TcpStream};
use std::task::TaskBuilder;
use std::time::Duration;
-#[start]
-fn start(argc: int, argv: *const *const u8) -> int {
- green::start(argc, argv, rustuv::event_loop, main)
-}
-
fn main() {
// This test has a chance to time out, try to not let it time out
spawn(proc() {
projects / rust.git / commitdiff