Initial import

tests/futures.rs

@@ -0,0 +1,54 @@
+use std::future::Future;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use std::task::Context;
+use std::task::Poll;
+use std::thread;
+
+#[test]
+fn test_simple() {
+    // Sanity check
+    assert_eq!(42, beul::execute(async { 42 }));
+
+    // Some more esoteric futures
+    beul::execute(async { async {}.await });
+    beul::execute(async { beul::execute(async {}) });
+}
+
+#[test]
+fn test_threaded_future() {
+    /// Dummy future that sleeps until a separate thread wakes it
+    ///
+    /// It returns the number of times it has been awoken
+    struct ThreadedFuture(Arc<AtomicBool>, usize);
+
+    impl Future for ThreadedFuture {
+        type Output = usize;
+
+        fn poll(mut self: std::pin::Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            // Note down that we've been polled
+            self.1 += 1;
+
+            if self.0.load(Ordering::Acquire) {
+                Poll::Ready(self.1)
+            } else {
+                if self.1 == 1 {
+                    let completer = Arc::clone(&self.0);
+                    let waker = cx.waker().clone();
+                    thread::spawn(move || {
+                        completer.store(true, Ordering::Release);
+                        waker.wake();
+                    });
+                }
+
+                Poll::Pending
+            }
+        }
+    }
+
+    let future = ThreadedFuture(Arc::new(AtomicBool::new(false)), 0);
+
+    // Future should be polled twice, once initially and once after the wake-up
+    assert_eq!(beul::execute(future), 2);
+}