Another round of attempting ignores

Author: alexcrichton

crates/test/src/csharp.rs

@@ -1,4 +1,4 @@
-use crate::{Compile, LanguageMethods, Runner, Verify};
+use crate::{Compile, Component, Kind, Language, LanguageMethods, RunCase, Runner, Verify};
 use anyhow::Result;
 use heck::*;
 use std::env;
@@ -53,6 +53,24 @@ impl LanguageMethods for Csharp {
         )
     }
 
+    fn should_fail_run(&self, _runner: &Runner, case: &RunCase<'_>, component: &Component) -> bool {
+        // TODO: remove these exclusions as bugs are fixed
+        match case.name {
+            // With a C# runner this test fails with "resource is of another
+            // type" when dropping a subtask.
+            "ping-pong" => component.kind == Kind::Runner,
+
+            // The C# test component fails to produce a result for its
+            // async-lifted export when its write is cancelled by a runner
+            // written in another language.
+            "future-cancel-read" => {
+                component.kind == Kind::Test && case.runner.language != Language::Csharp
+            }
+
+            _ => false,
+        }
+    }
+
     fn prepare(&self, runner: &mut Runner) -> Result<()> {
         runner.run_command(dotnet().arg("--version"))?;
 

crates/test/src/go.rs

@@ -1,4 +1,4 @@
-use crate::{Compile, LanguageMethods, Runner, Verify};
+use crate::{Compile, Component, Language, LanguageMethods, RunCase, Runner, Verify};
 use anyhow::{Context as _, Result};
 use std::env;
 use std::fs;
@@ -73,6 +73,19 @@ impl LanguageMethods for Go {
         false
     }
 
+    fn should_fail_run(
+        &self,
+        _runner: &Runner,
+        case: &RunCase<'_>,
+        _component: &Component,
+    ) -> bool {
+        // The C components of the `strings` test use `--string-encoding
+        // utf16`, so adapters composed between this Go component and a C
+        // component transcode strings, which requires reallocation support in
+        // `cabi_realloc` that the Go support library does not yet implement.
+        case.name == "strings" && case.components().any(|c| c.language == Language::C)
+    }
+
     fn default_bindgen_args_for_codegen(&self) -> &[&str] {
         &["--generate-stubs"]
     }

crates/test/src/lib.rs

@@ -251,6 +251,24 @@ struct Verify<'a> {
     world: &'a str,
 }
 
+/// Helper structure describing a single composed runtime test case, sent to
+/// `LanguageMethods::should_fail_run`.
+struct RunCase<'a> {
+    /// The name of the test, e.g. the directory name such as `ping-pong`.
+    name: &'a str,
+    /// The component providing the "runner" world for this case.
+    runner: &'a Component,
+    /// The components providing "test" worlds composed with `runner`.
+    tests: &'a [&'a Component],
+}
+
+impl RunCase<'_> {
+    /// Returns all components involved in this case.
+    fn components(&self) -> impl Iterator<Item = &Component> {
+        [self.runner].into_iter().chain(self.tests.iter().copied())
+    }
+}
+
 /// Helper structure to package up runtime state associated with executing tests.
 struct Runner {
     opts: Opts,
@@ -767,6 +785,16 @@ impl Runner {
                             component.path.file_name().unwrap().to_str().unwrap()
                         ));
                     }
+                    let should_fail = {
+                        let tests = test_components.iter().map(|(c, _)| c).collect::<Vec<_>>();
+                        let case = RunCase {
+                            name: &case_name,
+                            runner: &runner,
+                            tests: &tests,
+                        };
+                        case.components()
+                            .any(|c| c.language.obj().should_fail_run(self, &case, c))
+                    };
                     let case_name = case_name.to_string();
                     let runner = runner.clone();
                     let runner_path = runner_path.to_path_buf();
@@ -777,6 +805,7 @@ impl Runner {
                             .with_context(|| format!("failed to run `{}`", case.name));
                         me.render_error(
                             StepResult::new(result)
+                                .should_fail(should_fail)
                                 .metadata("runner", runner.path.display())
                                 .metadata("compiled runner", runner_path.display()),
                         )
@@ -1308,6 +1337,18 @@ trait LanguageMethods {
         false
     }
 
+    /// Returns whether this language expects the composed runtime test `case`
+    /// to fail to execute, where `component` is this language's component
+    /// within the case.
+    ///
+    /// This is invoked once per component in a case, so `component` may be
+    /// either the runner or one of the test components; the case is expected
+    /// to fail if any component's language says so.
+    fn should_fail_run(&self, runner: &Runner, case: &RunCase<'_>, component: &Component) -> bool {
+        let _ = (runner, case, component);
+        false
+    }
+
     /// Performs a "check" or a verify that the generated bindings described by
     /// `Verify` are indeed valid.
     fn verify(&self, runner: &Runner, verify: &Verify) -> Result<()>;