Alter wait wake test for better edge case handling + Cleanup comments

Author: LorrensP-2158466

tests/pass-dep/concurrency/freebsd-futex.rs

@@ -9,9 +9,9 @@ use std::{io, thread};
 
 fn wait_wake() {
     fn wake_nobody() {
-        // Current thread waits on futex
-        // New thread wakes up 0 threads waiting on that futex
-        // Current thread should time out
+        // Current thread waits on futex.
+        // New thread wakes up 0 threads waiting on that futex.
+        // Current thread should time out.
         static mut FUTEX: u32 = 0;
 
         let waker = thread::spawn(|| {
@@ -43,14 +43,14 @@ fn wait_wake() {
                 ),
                 -1
             );
-            // main thread did not get woken up, so it timed out
+            // Main thread did not get woken up, so it timed out.
             assert_eq!(io::Error::last_os_error().raw_os_error().unwrap(), libc::ETIMEDOUT);
         }
 
         waker.join().unwrap();
     }
 
-    fn wake_one() {
+    fn wake_two_of_three() {
         // We create 2 threads that wait on a futex with a 500ms timeout.
         // The main thread wakes up 1 thread waiting on this futex and after this
         // checks that only 1 thread woke up and the other timed out.
@@ -68,35 +68,40 @@ fn wait_wake() {
                     timeout_size_arg,
                     &mut timeout as *mut _ as _,
                 );
-                // Return wether this threads wait timed out or not.
-                io::Error::last_os_error().raw_os_error().unwrap() == libc::ETIMEDOUT
+                // Return true if this thread woke up.
+                io::Error::last_os_error().raw_os_error().unwrap() != libc::ETIMEDOUT
             }
         }
 
         let t1 = thread::spawn(waiter);
         let t2 = thread::spawn(waiter);
+        let t3 = thread::spawn(waiter);
 
         thread::yield_now();
-        // Wake up 1 thread and make sure the other is still waiting
+        // Wake up 2 thread and make sure 1 is still waiting.
         unsafe {
             assert_eq!(
                 libc::_umtx_op(
                     addr_of!(FUTEX) as *mut _,
                     libc::UMTX_OP_WAKE_PRIVATE,
-                    1,
+                    2,
                     ptr::null_mut::<libc::c_void>(),
                     ptr::null_mut::<libc::c_void>(),
                 ),
                 0
             );
         }
-        let t1_woke_up = t1.join().unwrap();
-        let t2_woke_up = t2.join().unwrap();
-        assert!(t1_woke_up ^ t2_woke_up, "Expected 1 thread to wake up");
+
+        // Treat the booleans as numbers to simplify checking how many threads were woken up.
+        let t1 = t1.join().unwrap() as usize;
+        let t2 = t2.join().unwrap() as usize;
+        let t3 = t3.join().unwrap() as usize;
+        let woken_up_count = t1 + t2 + t3;
+        assert!(woken_up_count == 2, "Expected 2 threads to wake up got: {woken_up_count}");
     }
 
     wake_nobody();
-    wake_one();
+    wake_two_of_three();
 }
 
 fn wake_dangling() {