Fix unstable tests after multi-os-ci

.github/workflows/rust.yml

@@ -10,7 +10,7 @@ env:
 jobs:
   build:
     strategy:
-      fail-fast: true
+      fail-fast: false
       matrix:
         include:
         - os: ubuntu-latest

src/immediatevalue.rs

@@ -104,7 +104,6 @@ impl<T: Send> ImmediateValuePromise<T> {
 mod test {
     use crate::immediatevalue::{ImmediateValuePromise, ImmediateValueState};
     use std::fs::File;
-    use std::thread;
     use std::time::Duration;
     use tokio::runtime::Runtime;
 
@@ -119,7 +118,7 @@ mod test {
                 oneshot_val.poll_state(),
                 ImmediateValueState::Updating
             ));
-            thread::sleep(Duration::from_millis(100));
+            tokio::time::sleep(Duration::from_millis(100)).await;
             let result = oneshot_val.poll_state();
             if let ImmediateValueState::Success(val) = result {
                 assert_eq!(*val, 34);
@@ -141,7 +140,7 @@ mod test {
                 oneshot_val.poll_state(),
                 ImmediateValueState::Updating
             ));
-            thread::sleep(Duration::from_millis(50));
+            tokio::time::sleep(Duration::from_millis(50)).await;
             let result = oneshot_val.poll_state();
             if let ImmediateValueState::Error(e) = result {
                 let _ = format!("{}", **e);

src/lazyvalue.rs

@@ -113,7 +113,7 @@ mod test {
     use super::*;
     use crate::unpack_result;
     use std::time::Duration;
-    use tokio::runtime::Runtime;
+    use tokio::runtime::{Builder, Runtime};
     use tokio::sync::mpsc::Sender;
 
     #[test]
@@ -128,26 +128,32 @@ mod test {
                 .unwrap();
         };
 
-        Runtime::new().unwrap().block_on(async {
-            let mut delayed_value = LazyValuePromise::new(string_maker, 6);
-            //be lazy:
-            assert!(delayed_value.is_uninitialized());
-            //start sets updating
-            assert_eq!(*delayed_value.poll_state(), DataState::Updating(0.0.into()));
-            assert!(delayed_value.value().is_none());
-            //after wait, value is there
-            std::thread::sleep(Duration::from_millis(150));
-            assert_eq!(*delayed_value.poll_state(), DataState::UpToDate);
-            assert_eq!(delayed_value.value().unwrap(), "1");
-            //update resets
-            delayed_value.update();
-            assert_eq!(*delayed_value.poll_state(), DataState::Updating(0.0.into()));
-            assert!(delayed_value.value().is_none());
-            //after wait, value is there again and identical
-            std::thread::sleep(Duration::from_millis(150));
-            assert_eq!(*delayed_value.poll_state(), DataState::UpToDate);
-            assert_eq!(delayed_value.value().unwrap(), "1");
-        });
+        Builder::new_multi_thread()
+            .worker_threads(2)
+            .enable_time()
+            .max_blocking_threads(2)
+            .build()
+            .unwrap()
+            .block_on(async {
+                let mut delayed_value = LazyValuePromise::new(string_maker, 6);
+                //be lazy:
+                assert!(delayed_value.is_uninitialized());
+                //start sets updating
+                assert_eq!(*delayed_value.poll_state(), DataState::Updating(0.0.into()));
+                assert!(delayed_value.value().is_none());
+                //after wait, value is there
+                tokio::time::sleep(Duration::from_millis(150)).await;
+                assert_eq!(*delayed_value.poll_state(), DataState::UpToDate);
+                assert_eq!(delayed_value.value().unwrap(), "1");
+                //update resets
+                delayed_value.update();
+                assert_eq!(*delayed_value.poll_state(), DataState::Updating(0.0.into()));
+                assert!(delayed_value.value().is_none());
+                //after wait, value is there again and identical
+                tokio::time::sleep(Duration::from_millis(150)).await;
+                assert_eq!(*delayed_value.poll_state(), DataState::UpToDate);
+                assert_eq!(delayed_value.value().unwrap(), "1");
+            });
     }
 
     #[test]
@@ -163,7 +169,7 @@ mod test {
             let mut delayed_vec = LazyValuePromise::new(error_maker, 1);
             assert_eq!(*delayed_vec.poll_state(), DataState::Updating(0.0.into()));
             assert!(delayed_vec.value().is_none());
-            std::thread::sleep(Duration::from_millis(150));
+            tokio::time::sleep(Duration::from_millis(150)).await;
             assert!(matches!(*delayed_vec.poll_state(), DataState::Error(_)));
             assert!(delayed_vec.value().is_none());
         });

src/lazyvec.rs

@@ -34,7 +34,7 @@ use tokio::sync::mpsc::{channel, Receiver, Sender};
 /// fn main_loop(lazy_promise: &mut LazyVecPromise<i32>) {
 ///   loop {
 ///     match lazy_promise.poll_state() {
-///       DataState::Error(er)  => { println!("Error {} occurred! Retrying!", er); std::thread::sleep(Duration::from_millis(500)); lazy_promise.update(); }
+///       DataState::Error(er)  => { println!("Error {} occurred! Retrying!", er); std::thread::sleep(Duration::from_millis(50)); lazy_promise.update(); }
 ///       DataState::UpToDate   => { println!("Data complete: {:?}", lazy_promise.as_slice()); }
 ///                           _ => { println!("Getting data, might be partially ready! (part: {:?}", lazy_promise.as_slice()); }  
 ///     }
@@ -120,7 +120,7 @@ mod test {
     use super::*;
     use crate::{set_progress, unpack_result, Progress};
     use std::time::Duration;
-    use tokio::runtime::Runtime;
+    use tokio::runtime::{Builder, Runtime};
     use tokio::sync::mpsc::Sender;
 
     #[test]
@@ -137,29 +137,42 @@ mod test {
                 .unwrap();
         };
 
-        Runtime::new().unwrap().block_on(async {
-            let mut delayed_vec = LazyVecPromise::new(string_maker, 12);
-            // start empty, polling triggers update
-            assert!(delayed_vec.is_uninitialized());
-            assert_eq!(*delayed_vec.poll_state(), DataState::Updating(0.0.into()));
-            assert!(delayed_vec.as_slice().is_empty());
-            // We have some numbers ready in between
-            std::thread::sleep(Duration::from_millis(80));
-            assert_eq!(*delayed_vec.poll_state(), DataState::Updating(0.6.into()));
-            assert_eq!(delayed_vec.as_slice().len(), 4);
-            // after wait we have a result
-            std::thread::sleep(Duration::from_millis(40));
-            assert_eq!(*delayed_vec.poll_state(), DataState::UpToDate);
-            assert_eq!(delayed_vec.as_slice().len(), 5);
-            // after update it's empty again
-            delayed_vec.update();
-            assert_eq!(*delayed_vec.poll_state(), DataState::Updating(0.0.into()));
-            assert!(delayed_vec.as_slice().is_empty());
-            // finally after waiting it's full again
-            std::thread::sleep(Duration::from_millis(150));
-            assert_eq!(*delayed_vec.poll_state(), DataState::UpToDate);
-            assert_eq!(delayed_vec.as_slice().len(), 5);
-        });
+        Builder::new_multi_thread()
+            .worker_threads(2)
+            .enable_time()
+            .max_blocking_threads(2)
+            .build()
+            .unwrap()
+            .block_on(async {
+                let mut delayed_vec = LazyVecPromise::new(string_maker, 12);
+                // start empty, polling triggers update
+                assert!(delayed_vec.is_uninitialized());
+                assert_eq!(*delayed_vec.poll_state(), DataState::Updating(0.0.into()));
+                println!("Slice is: {:?}", delayed_vec.as_slice());
+                assert!(delayed_vec.as_slice().is_empty());
+                // We have some numbers ready in between
+                tokio::time::sleep(Duration::from_millis(80)).await;
+                if let DataState::Updating(progress) = delayed_vec.poll_state() {
+                    assert!(progress.as_f32() > 0.0);
+                    assert!(progress.as_f32() < 1.0);
+                    assert!(!delayed_vec.as_slice().is_empty());
+                } else {
+                    panic!("Was not in updating state after waiting time");
+                }
+
+                // after wait we have a result
+                tokio::time::sleep(Duration::from_millis(200)).await;
+                assert_eq!(*delayed_vec.poll_state(), DataState::UpToDate);
+                assert_eq!(delayed_vec.as_slice().len(), 5);
+                // after update it's empty again
+                delayed_vec.update();
+                assert_eq!(*delayed_vec.poll_state(), DataState::Updating(0.0.into()));
+                assert!(delayed_vec.as_slice().is_empty());
+                // finally after waiting it's full again
+                tokio::time::sleep(Duration::from_millis(400)).await;
+                assert_eq!(*delayed_vec.poll_state(), DataState::UpToDate);
+                assert_eq!(delayed_vec.as_slice().len(), 5);
+            });
     }
 
     #[test]
@@ -175,7 +188,7 @@ mod test {
             let mut delayed_vec = LazyVecPromise::new(error_maker, 1);
             assert_eq!(*delayed_vec.poll_state(), DataState::Updating(0.0.into()));
             assert!(delayed_vec.as_slice().is_empty());
-            std::thread::sleep(Duration::from_millis(150));
+            tokio::time::sleep(Duration::from_millis(200)).await;
             assert!(matches!(*delayed_vec.poll_state(), DataState::Error(_)));
             assert!(delayed_vec.as_slice().is_empty());
         });

src/lib.rs

@@ -174,5 +174,7 @@ mod test {
         assert_eq!(minimum.as_f32(), 0.0);
         let maximum = Progress::from_fraction(2, 1);
         assert_eq!(maximum.as_f64(), 1.0);
+        let progress: Progress = 2.0.into();
+        assert_eq!(progress.as_f64(), 1.0);
     }
 }