Added a timeout to the integration tests

Author: bvinc

tests/support/harness.rs

@@ -64,7 +64,8 @@ pub fn read_message<R: Read>(reader: &mut BufReader<R>) -> io::Result<String> {
 pub fn expect_messages<R: Read>(reader: &mut BufReader<R>, expected: &[&ExpectedMessage]) {
     let mut results: Vec<String> = Vec::new();
     while results.len() < expected.len() {
-        results.push(read_message(reader).unwrap());
+        let msg = read_message(reader).unwrap();
+        results.push(msg);
     }
 
     println!(
@@ -161,4 +162,4 @@ impl RlsHandle {
     pub fn expect_messages(&mut self, expected: &[&ExpectedMessage]) {
         expect_messages(&mut self.stdout, expected);
     }
-}
+}

tests/tests.rs

@@ -13,119 +13,154 @@ extern crate cargo;
 #[macro_use]
 extern crate serde_json;
 
+use std::sync::{Arc, Condvar, Mutex};
+use std::thread;
+use std::time::Duration;
+
 mod support;
 use support::{basic_bin_manifest, project};
 use support::harness::{ExpectedMessage, RlsHandle};
 
+fn timeout<F>(dur: Duration, func: F)
+    where F: FnOnce() + Send + 'static {
+    let pair = Arc::new((Mutex::new(false), Condvar::new()));
+    let pair2 = pair.clone();
+
+    thread::spawn(move|| {
+        let &(ref lock, ref cvar) = &*pair2;
+        func();
+        let mut finished = lock.lock().unwrap();
+        *finished = true;
+        // We notify the condvar that the value has changed.
+        cvar.notify_one();
+    });
+
+    // Wait for the test to finish.
+    let &(ref lock, ref cvar) = &*pair;
+    let mut finished = lock.lock().unwrap();
+    // As long as the value inside the `Mutex` is false, we wait.
+    while !*finished {
+        let result = cvar.wait_timeout(finished, dur).unwrap();
+        if result.1.timed_out() {
+            panic!("Timed out")
+        }
+        finished = result.0
+    }
+}
+
 #[test]
 fn test_infer_bin() {
-    let p = project("simple_workspace")
-        .file("Cargo.toml", &basic_bin_manifest("foo"))
-        .file("src/main.rs", r#"
-            struct UnusedBin;
-            fn main() {
-                println!("Hello world!");
-            }
-        "#)
-        .build();
-
-    let root_path = p.root();
-    let rls_child = p.rls().spawn().unwrap();
-    let mut rls = RlsHandle::new(rls_child);
-
-    rls.request(0, "initialize", json!({
-        "rootPath": root_path,
-        "capabilities": {}
-    })).unwrap();
-
-    rls.expect_messages(&[
-        ExpectedMessage::new(Some(0)).expect_contains("capabilities"),
-        ExpectedMessage::new(None).expect_contains("beginBuild"),
-        ExpectedMessage::new(None).expect_contains("diagnosticsBegin"),
-        ExpectedMessage::new(None).expect_contains("struct is never used: `UnusedBin`"),
-        ExpectedMessage::new(None).expect_contains("diagnosticsEnd")
-    ]);
-
-    rls.shutdown_exit();
+    timeout(Duration::from_secs(300), ||{
+        let p = project("simple_workspace")
+            .file("Cargo.toml", &basic_bin_manifest("foo"))
+            .file("src/main.rs", r#"
+                struct UnusedBin;
+                fn main() {
+                    println!("Hello world!");
+                }
+            "#)
+            .build();
+
+        let root_path = p.root();
+        let rls_child = p.rls().spawn().unwrap();
+        let mut rls = RlsHandle::new(rls_child);
+
+        rls.request(0, "initialize", json!({
+            "rootPath": root_path,
+            "capabilities": {}
+        })).unwrap();
+
+        rls.expect_messages(&[
+            ExpectedMessage::new(Some(0)).expect_contains("capabilities"),
+            ExpectedMessage::new(None).expect_contains("beginBuild"),
+            ExpectedMessage::new(None).expect_contains("diagnosticsBegin"),
+            ExpectedMessage::new(None).expect_contains("struct is never used: `UnusedBin`"),
+            ExpectedMessage::new(None).expect_contains("diagnosticsEnd")
+        ]);
+
+        rls.shutdown_exit();
+    });
 }
 
 #[test]
 fn test_simple_workspace() {
-    let p = project("simple_workspace")
-        .file("Cargo.toml", r#"
-            [workspace]
-            members = [
-              "member_lib",
-              "member_bin",
-            ]
-        "#)
-        .file("Cargo.lock", r#"
-            [root]
-            name = "member_lib"
-            version = "0.1.0"
-            		
-            [[package]]
-            name = "member_bin"
-            version = "0.1.0"
-            dependencies = [
-             "member_lib 0.1.0",
-            ]
-        "#)
-        .file("member_bin/Cargo.toml", r#"
-            [package]
-            name = "member_bin"
-            version = "0.1.0"
-            authors = ["Igor Matuszewski <[email protected]>"]
-
-            [dependencies]
-            member_lib = { path = "../member_lib" }
-        "#)
-        .file("member_bin/src/main.rs", r#"
-            extern crate member_lib;
-
-            fn main() {
-                let a = member_lib::MemberLibStruct;
-            }
-        "#)
-        .file("member_lib/Cargo.toml", r#"
-            [package]
-            name = "member_lib"
-            version = "0.1.0"
-            authors = ["Igor Matuszewski <[email protected]>"]
-
-            [dependencies]
-        "#)
-        .file("member_lib/src/lib.rs", r#"
-            pub struct MemberLibStruct;
-
-            struct Unused;
-
-            #[cfg(test)]
-            mod tests {
-                #[test]
-                fn it_works() {
+    timeout(Duration::from_secs(300), ||{
+        let p = project("simple_workspace")
+            .file("Cargo.toml", r#"
+                [workspace]
+                members = [
+                "member_lib",
+                "member_bin",
+                ]
+            "#)
+            .file("Cargo.lock", r#"
+                [root]
+                name = "member_lib"
+                version = "0.1.0"
+                        
+                [[package]]
+                name = "member_bin"
+                version = "0.1.0"
+                dependencies = [
+                "member_lib 0.1.0",
+                ]
+            "#)
+            .file("member_bin/Cargo.toml", r#"
+                [package]
+                name = "member_bin"
+                version = "0.1.0"
+                authors = ["Igor Matuszewski <[email protected]>"]
+
+                [dependencies]
+                member_lib = { path = "../member_lib" }
+            "#)
+            .file("member_bin/src/main.rs", r#"
+                extern crate member_lib;
+
+                fn main() {
+                    let a = member_lib::MemberLibStruct;
+                }
+            "#)
+            .file("member_lib/Cargo.toml", r#"
+                [package]
+                name = "member_lib"
+                version = "0.1.0"
+                authors = ["Igor Matuszewski <[email protected]>"]
+
+                [dependencies]
+            "#)
+            .file("member_lib/src/lib.rs", r#"
+                pub struct MemberLibStruct;
+
+                struct Unused;
+
+                #[cfg(test)]
+                mod tests {
+                    #[test]
+                    fn it_works() {
+                    }
                 }
-            }        
-        "#)
-        .build();
-
-    let root_path = p.root();
-    let rls_child = p.rls().spawn().unwrap();
-    let mut rls = RlsHandle::new(rls_child);
-
-    rls.request(0, "initialize", json!({
-        "rootPath": root_path,
-        "capabilities": {}
-    })).unwrap();
-
-    rls.expect_messages(&[
-        ExpectedMessage::new(Some(0)).expect_contains("capabilities"),
-        ExpectedMessage::new(None).expect_contains("beginBuild"),
-        ExpectedMessage::new(None).expect_contains("diagnosticsBegin"),
-        ExpectedMessage::new(None).expect_contains("publishDiagnostics"),
-        ExpectedMessage::new(None).expect_contains("publishDiagnostics"),
-        ExpectedMessage::new(None).expect_contains("diagnosticsEnd")
-    ]);
-
-    rls.shutdown_exit();
-}
+            "#)
+            .build();
+
+        let root_path = p.root();
+        let rls_child = p.rls().spawn().unwrap();
+        let mut rls = RlsHandle::new(rls_child);
+
+        rls.request(0, "initialize", json!({
+            "rootPath": root_path,
+            "capabilities": {}
+        })).unwrap();
+
+        rls.expect_messages(&[
+            ExpectedMessage::new(Some(0)).expect_contains("capabilities"),
+            ExpectedMessage::new(None).expect_contains("beginBuild"),
+            ExpectedMessage::new(None).expect_contains("diagnosticsBegin"),
+            ExpectedMessage::new(None).expect_contains("publishDiagnostics"),
+            ExpectedMessage::new(None).expect_contains("publishDiagnostics"),
+            ExpectedMessage::new(None).expect_contains("diagnosticsEnd")
+        ]);
+
+        rls.shutdown_exit();
+    });
+}