Test that exits are processed without code being run

* Exits that occur in the run Code are processed in the same iteration
  of the loop.
* Exits that occur external to the loop prevent Code from being run at
  all.

Author: KronicDeth

lumen_runtime/src/scheduler.rs

@@ -1,3 +1,6 @@
+#[cfg(test)]
+pub mod test;
+
 use core::fmt::{self, Debug};
 use core::sync::atomic::{AtomicU64, Ordering};
 
@@ -134,6 +137,8 @@ impl Scheduler {
                                 *arc_process.acquire_heap()
                             ),
                         }
+                    } else {
+                        arc_process.reduce()
                     }
 
                     match self.run_queues.write().requeue(arc_process) {
@@ -401,57 +406,3 @@ where
 {
     f(process::test(&process::test_init()))
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    mod scheduler {
-        use super::*;
-
-        mod new_process {
-            use super::*;
-
-            use liblumen_alloc::erts::process::default_heap;
-            use liblumen_alloc::erts::term::atom_unchecked;
-
-            #[test]
-            fn different_processes_have_different_pids() {
-                let erlang = Atom::try_from_str("erlang").unwrap();
-                let exit = Atom::try_from_str("exit").unwrap();
-                let normal = atom_unchecked("normal");
-                let parent_arc_process_control_block = process::test_init();
-
-                let first_process_arguments = parent_arc_process_control_block
-                    .list_from_slice(&[normal])
-                    .unwrap();
-                let (first_heap, first_heap_size) = default_heap().unwrap();
-                let first_process = Scheduler::spawn_apply_3(
-                    &parent_arc_process_control_block,
-                    erlang,
-                    exit,
-                    first_process_arguments,
-                    first_heap,
-                    first_heap_size,
-                )
-                .unwrap();
-
-                let second_process_arguments = parent_arc_process_control_block
-                    .list_from_slice(&[normal])
-                    .unwrap();
-                let (second_heap, second_heap_size) = default_heap().unwrap();
-                let second_process = Scheduler::spawn_apply_3(
-                    &first_process,
-                    erlang,
-                    exit,
-                    second_process_arguments,
-                    second_heap,
-                    second_heap_size,
-                )
-                .unwrap();
-
-                assert_ne!(first_process.pid_term(), second_process.pid_term());
-            }
-        }
-    }
-}

lumen_runtime/src/scheduler/test.rs

@@ -0,0 +1,44 @@
+mod spawn_apply_3;
+
+use liblumen_alloc::erts::process::code::stack::frame::Placement;
+use liblumen_alloc::erts::term::atom_unchecked;
+
+use crate::otp::erlang::exit_1;
+use crate::scheduler::{with_process_arc, Scheduler};
+
+#[test]
+fn scheduler_does_not_requeue_exiting_process() {
+    with_process_arc(|arc_process| {
+        exit_1::place_frame_with_arguments(
+            &arc_process,
+            Placement::Replace,
+            atom_unchecked("normal"),
+        )
+        .unwrap();
+
+        let scheduler = Scheduler::current();
+
+        assert!(scheduler.is_run_queued(&arc_process));
+
+        assert!(scheduler.run_through(&arc_process));
+
+        assert!(!scheduler.is_run_queued(&arc_process));
+    })
+}
+
+#[test]
+fn scheduler_does_run_exiting_process() {
+    with_process_arc(|arc_process| {
+        let scheduler = Scheduler::current();
+
+        assert!(scheduler.is_run_queued(&arc_process));
+        assert!(scheduler.run_through(&arc_process));
+        assert!(scheduler.is_run_queued(&arc_process));
+
+        arc_process.exit();
+
+        assert!(scheduler.is_run_queued(&arc_process));
+        assert!(!scheduler.run_through(&arc_process));
+        assert!(!scheduler.is_run_queued(&arc_process));
+    })
+}

lumen_runtime/src/scheduler/test/spawn_apply_3.rs

@@ -0,0 +1,44 @@
+use super::*;
+
+use liblumen_alloc::erts::process::default_heap;
+use liblumen_alloc::erts::term::{atom_unchecked, Atom};
+
+use crate::process;
+
+#[test]
+fn different_processes_have_different_pids() {
+    let erlang = Atom::try_from_str("erlang").unwrap();
+    let exit = Atom::try_from_str("exit").unwrap();
+    let normal = atom_unchecked("normal");
+    let parent_arc_process_control_block = process::test_init();
+
+    let first_process_arguments = parent_arc_process_control_block
+        .list_from_slice(&[normal])
+        .unwrap();
+    let (first_heap, first_heap_size) = default_heap().unwrap();
+    let first_process = Scheduler::spawn_apply_3(
+        &parent_arc_process_control_block,
+        erlang,
+        exit,
+        first_process_arguments,
+        first_heap,
+        first_heap_size,
+    )
+    .unwrap();
+
+    let second_process_arguments = parent_arc_process_control_block
+        .list_from_slice(&[normal])
+        .unwrap();
+    let (second_heap, second_heap_size) = default_heap().unwrap();
+    let second_process = Scheduler::spawn_apply_3(
+        &first_process,
+        erlang,
+        exit,
+        second_process_arguments,
+        second_heap,
+        second_heap_size,
+    )
+    .unwrap();
+
+    assert_ne!(first_process.pid_term(), second_process.pid_term());
+}