asm test

Author: shepmaster

orchestrator/Cargo.lock

@@ -17,4 +17,5 @@ tokio-util = { version = "0.7.8", default-features = false, features = ["io", "i
 toml = { version = "0.7.3", default-features = false, features = ["parse", "display"] }
 
 [dev-dependencies]
+assertables = "7.0.1"
 tempdir = "0.3.7"

orchestrator/Cargo.toml

@@ -709,14 +709,19 @@ fn spawn_io_queue(stdin: ChildStdin, stdout: ChildStdout, token: CancellationTok
 
 #[cfg(test)]
 mod tests {
+    use assertables::*;
+    use futures::{Future, FutureExt};
     use std::{sync::Once, time::Duration};
     use tempdir::TempDir;
     use tokio::join;
     use tokio_stream::{wrappers::ReceiverStream, StreamExt};
 
     use crate::{
         coordinator::Coordinator,
-        sandbox::{Channel, CompileRequest, CompileTarget, CrateType, Edition, Mode},
+        sandbox::{
+            AssemblyFlavor, Channel, CompileRequest, CompileTarget, CrateType, DemangleAssembly,
+            Edition, LibraryType, Mode, ProcessAssembly,
+        },
     };
 
     use super::*;
@@ -749,6 +754,9 @@ mod tests {
                 .expect("Build failed");
             assert!(output.status.success(), "Cargo initialization failed");
 
+            let main = project_dir.path().join("src").join("main.rs");
+            std::fs::remove_file(main).expect("Could not delete main.rs");
+
             Self { project_dir }
         }
     }
@@ -767,10 +775,27 @@ mod tests {
 
     fn new_coordinator() -> Result<Coordinator<impl Backend>> {
         Coordinator::new(TestBackend::new())
-        // Coordinator::new_docker()
+        //Coordinator::new_docker()
     }
 
-    fn new_compile_request() -> CompileRequest {
+    fn new_compile_asm_request() -> CompileRequest {
+        CompileRequest {
+            target: CompileTarget::Assembly(
+                AssemblyFlavor::Intel,
+                DemangleAssembly::Demangle,
+                ProcessAssembly::Filter,
+            ),
+            channel: Channel::Beta,
+            crate_type: CrateType::Library(LibraryType::Lib),
+            mode: Mode::Release,
+            edition: Edition::Rust2018,
+            tests: false,
+            backtrace: false,
+            code: r#"pub fn add(a: u8, b: u8) -> u8 { a + b }"#.to_owned(),
+        }
+    }
+
+    fn new_compile_mir_request() -> CompileRequest {
         CompileRequest {
             target: CompileTarget::Mir,
             channel: Channel::Stable,
@@ -783,20 +808,24 @@ mod tests {
         }
     }
 
+    fn new_compile_request() -> CompileRequest {
+        new_compile_mir_request()
+    }
+
     #[tokio::test]
     #[snafu::report]
     async fn test_compile_response() -> Result<()> {
         let coordinator = new_coordinator()?;
 
-        let response = tokio::time::timeout(
-            Duration::from_millis(5000),
-            coordinator.compile(new_compile_request()),
-        )
-        .await
-        .expect("Failed to receive streaming from container in time")
-        .unwrap();
+        let response = coordinator
+            .compile(new_compile_request())
+            .with_timeout()
+            .await
+            .unwrap();
 
-        assert!(response.success);
+        assert!(response.success, "stderr: {}", response.stderr);
+        assert_contains!(response.stderr, "Compiling");
+        assert_contains!(response.stderr, "Finished");
 
         coordinator.shutdown().await?;
 
@@ -824,21 +853,55 @@ mod tests {
         let stderr = stderr.collect::<String>();
 
         let (complete, _stdout, stderr) =
-            tokio::time::timeout(Duration::from_millis(5000), async move {
-                join!(task, stdout, stderr)
-            })
+            async { join!(task, stdout, stderr) }.with_timeout().await;
+
+        let response = complete.unwrap().unwrap();
+
+        assert!(response.success, "stderr: {}", stderr);
+        assert_contains!(stderr, "Compiling");
+        assert_contains!(stderr, "Finished");
+
+        coordinator.shutdown().await?;
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    #[snafu::report]
+    async fn test_compile_assembly() -> Result<()> {
+        let coordinator = new_coordinator()?;
+
+        let response = coordinator
+            .compile(new_compile_asm_request())
+            .with_timeout()
             .await
-            .expect("Failed to receive streaming from container in time");
+            .unwrap();
+
+        //#[cfg(target_arch = "x86_64")]
+        //let asm = "";
+
+        #[cfg(target_arch = "aarch64")]
+        let asm = "w0, w1, w0";
 
-        complete.unwrap().unwrap();
-        assert!(
-            stderr.contains("Compiling"),
-            "Missing `Compiling`: {stderr}"
-        );
-        assert!(stderr.contains("Finished"), "Missing `Finished`: {stderr}");
+        assert!(response.success, "stderr: {}", response.stderr);
+        assert_contains!(response.code, asm);
 
         coordinator.shutdown().await?;
 
         Ok(())
     }
+
+    trait TimeoutExt: Future + Sized {
+        fn with_timeout(
+            self,
+        ) -> futures::future::Map<
+            tokio::time::Timeout<Self>,
+            fn(Result<Self::Output, tokio::time::error::Elapsed>) -> Self::Output,
+        > {
+            tokio::time::timeout(Duration::from_millis(5000), self)
+                .map(|v| v.expect("The operation timed out"))
+        }
+    }
+
+    impl<F: Future> TimeoutExt for F {}
 }

orchestrator/src/coordinator.rs

@@ -101,8 +101,13 @@ pub struct CompileRequest {
 
 impl CompileRequest {
     pub(crate) fn write_main_request(&self) -> WriteFileRequest {
+        let path = match self.crate_type {
+            CrateType::Binary => "src/main.rs",
+            CrateType::Library(_) => "src/lib.rs",
+        };
+
         WriteFileRequest {
-            path: "src/main.rs".to_owned(),
+            path: path.to_owned(),
             content: self.code.clone().into(),
         }
     }