---

yaml
---
r: 96922
b: refs/heads/dist-snap
c: f5d9b2c
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 018d60509c04cdebdf8b0d9e2b58f2604538e516
+refs/heads/dist-snap: f5d9b2ca6d9a360112f06b3044897c22736c52b8
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libnative/io/file.rs

@@ -899,8 +899,7 @@ pub fn utime(p: &CString, atime: u64, mtime: u64) -> IoResult<()> {
 
 #[cfg(test)]
 mod tests {
-    use std::io::native::file::{CFile, FileDesc};
-    use std::io::fs;
+    use super::{CFile, FileDesc};
     use std::io;
     use std::libc;
     use std::os;

branches/dist-snap/src/libnative/lib.rs

@@ -24,38 +24,64 @@
 #[crate_type = "rlib"];
 #[crate_type = "dylib"];
 
+#[cfg(stage0, test)] extern mod green;
+
 // NB this crate explicitly does *not* allow glob imports, please seriously
-//    consider whether they're needed before adding that feature here.
+//    consider whether they're needed before adding that feature here (the
+//    answer is that you don't need them)
 
-use std::cast;
 use std::os;
 use std::rt;
-use std::task::try;
 
 pub mod io;
 pub mod task;
 
+
 // XXX: this should not exist here
-#[cfg(stage0)]
+#[cfg(stage0, notready)]
 #[lang = "start"]
-pub fn start(main: *u8, argc: int, argv: **u8) -> int {
-    rt::init(argc, argv);
+pub fn lang_start(main: *u8, argc: int, argv: **u8) -> int {
+    use std::cast;
+    use std::task::try;
 
-    // Bootstrap ourselves by installing a local Task and then immediately
-    // spawning a thread to run 'main'. Always spawn a new thread for main so
-    // the stack size of 'main' is known (and the bounds can be set
-    // appropriately).
-    //
-    // Once the main task has completed, then we wait for everyone else to exit.
-    task::run(task::new(), proc() {
+    do start(argc, argv) {
+        // Instead of invoking main directly on this thread, invoke it on
+        // another spawned thread that we are guaranteed to know the size of the
+        // stack of. Currently, we do not have a method of figuring out the size
+        // of the main thread's stack, so for stack overflow detection to work
+        // we must spawn the task in a subtask which we know the stack size of.
         let main: extern "Rust" fn() = unsafe { cast::transmute(main) };
         match do try { main() } {
             Ok(()) => { os::set_exit_status(0); }
             Err(..) => { os::set_exit_status(rt::DEFAULT_ERROR_CODE); }
         }
-    });
-    task::wait_for_completion();
+    }
+}
 
+/// Executes the given procedure after initializing the runtime with the given
+/// argc/argv.
+///
+/// This procedure is guaranteed to run on the thread calling this function, but
+/// the stack bounds for this rust task will *not* be set. Care must be taken
+/// for this function to not overflow its stack.
+///
+/// This function will only return once *all* native threads in the system have
+/// exited.
+pub fn start(argc: int, argv: **u8, main: proc()) -> int {
+    rt::init(argc, argv);
+    let exit_code = run(main);
     unsafe { rt::cleanup(); }
+    return exit_code;
+}
+
+/// Executes a procedure on the current thread in a Rust task context.
+///
+/// This function has all of the same details as `start` except for a different
+/// number of arguments.
+pub fn run(main: proc()) -> int {
+    // Create a task, run the procedure in it, and then wait for everything.
+    task::run(task::new(), main);
+    task::wait_for_completion();
+
     os::get_exit_status()
 }

branches/dist-snap/src/libnative/task.rs

@@ -260,3 +260,100 @@ impl Drop for Ops {
         unsafe { self.lock.destroy() }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::rt::Runtime;
+    use std::rt::local::Local;
+    use std::rt::task::Task;
+    use std::task;
+    use super::{spawn, spawn_opts, Ops};
+
+    #[test]
+    fn smoke() {
+        let (p, c) = Chan::new();
+        do spawn {
+            c.send(());
+        }
+        p.recv();
+    }
+
+    #[test]
+    fn smoke_fail() {
+        let (p, c) = Chan::<()>::new();
+        do spawn {
+            let _c = c;
+            fail!()
+        }
+        assert_eq!(p.recv_opt(), None);
+    }
+
+    #[test]
+    fn smoke_opts() {
+        let mut opts = task::default_task_opts();
+        opts.name = Some(SendStrStatic("test"));
+        opts.stack_size = Some(20 * 4096);
+        let (p, c) = Chan::new();
+        opts.notify_chan = Some(c);
+        spawn_opts(opts, proc() {});
+        assert!(p.recv().is_ok());
+    }
+
+    #[test]
+    fn smoke_opts_fail() {
+        let mut opts = task::default_task_opts();
+        let (p, c) = Chan::new();
+        opts.notify_chan = Some(c);
+        spawn_opts(opts, proc() { fail!() });
+        assert!(p.recv().is_err());
+    }
+
+    #[test]
+    fn yield_test() {
+        let (p, c) = Chan::new();
+        do spawn {
+            10.times(task::deschedule);
+            c.send(());
+        }
+        p.recv();
+    }
+
+    #[test]
+    fn spawn_children() {
+        let (p, c) = Chan::new();
+        do spawn {
+            let (p, c2) = Chan::new();
+            do spawn {
+                let (p, c3) = Chan::new();
+                do spawn {
+                    c3.send(());
+                }
+                p.recv();
+                c2.send(());
+            }
+            p.recv();
+            c.send(());
+        }
+        p.recv();
+    }
+
+    #[test]
+    fn spawn_inherits() {
+        let (p, c) = Chan::new();
+        do spawn {
+            let c = c;
+            do spawn {
+                let mut task: ~Task = Local::take();
+                match task.maybe_take_runtime::<Ops>() {
+                    Some(ops) => {
+                        task.put_runtime(ops as ~Runtime);
+                    }
+                    None => fail!(),
+                }
+                Local::put(task);
+                c.send(());
+            }
+        }
+        p.recv();
+    }
+}