mtest: Add support for rust unit tests

Rust has it's own built in unit test format, which is invoked by
compiling a rust executable with the `--test` flag to rustc. The tests
are then run by simply invoking that binary. They output a custom test
format, which this patch adds parsing support for. This means that we
can report each subtest in the junit we generate correctly, which should
be helpful for orchestration systems like gitlab and jenkins which can
parse junit XML.

Author: dcbaker

docs/markdown/Reference-manual.md

@@ -1740,6 +1740,7 @@ test(..., env: nomalloc, ...)
     to record the outcome of the test).
   - `tap`: [Test Anything Protocol](https://www.testanything.org/).
   - `gtest` *(since 0.55.0)*: for Google Tests.
+  - `rust` *(since 0.56.0)*: for native rust tests
 
 - `priority` *(since 0.52.0)*:specifies the priority of a test. Tests with a
   higher priority are *started* before tests with a lower priority.

docs/markdown/snippets/rust_test_format_support.md

@@ -0,0 +1,4 @@
+## Meson test() now accepts `protocol : 'rust'`
+
+This allows native rust tests to be run and parsed by meson, simply set the
+protocol to `rust` and meson takes care of the rest.

mesonbuild/backend/backends.py

@@ -44,6 +44,7 @@ class TestProtocol(enum.Enum):
     EXITCODE = 0
     TAP = 1
     GTEST = 2
+    RUST = 3
 
     @classmethod
     def from_str(cls, string: str) -> 'TestProtocol':
@@ -53,13 +54,17 @@ def from_str(cls, string: str) -> 'TestProtocol':
             return cls.TAP
         elif string == 'gtest':
             return cls.GTEST
+        elif string == 'rust':
+            return cls.RUST
         raise MesonException('unknown test format {}'.format(string))
 
     def __str__(self) -> str:
         if self is self.EXITCODE:
             return 'exitcode'
         elif self is self.GTEST:
             return 'gtest'
+        elif self is self.RUST:
+            return 'rust'
         return 'tap'
 
 

mesonbuild/interpreter.py

@@ -4080,6 +4080,8 @@ def func_benchmark(self, node, args, kwargs):
     def func_test(self, node, args, kwargs):
         if kwargs.get('protocol') == 'gtest':
             FeatureNew.single_use('"gtest" protocol for tests', '0.55.0', self.subproject)
+        elif kwargs.get('protocol') == 'rust':
+            FeatureNew.single_use('"rust" protocol for tests', '0.56.0', self.subproject)
         self.add_test(node, args, kwargs, True)
 
     def unpack_env_kwarg(self, kwargs) -> build.EnvironmentVariables:
@@ -4136,8 +4138,8 @@ def add_test(self, node, args, kwargs, is_base_test):
         if not isinstance(timeout, int):
             raise InterpreterException('Timeout must be an integer.')
         protocol = kwargs.get('protocol', 'exitcode')
-        if protocol not in {'exitcode', 'tap', 'gtest'}:
-            raise InterpreterException('Protocol must be "exitcode", "tap", or "gtest".')
+        if protocol not in {'exitcode', 'tap', 'gtest', 'rust'}:
+            raise InterpreterException('Protocol must be one of "exitcode", "tap", "gtest", or "rust".')
         suite = []
         prj = self.subproject if self.is_subproject() else self.build.project_name
         for s in mesonlib.stringlistify(kwargs.get('suite', '')):

mesonbuild/mtest.py

@@ -326,7 +326,6 @@ def parse(self) -> T.Generator[T.Union['TAPParser.Test', 'TAPParser.Error', 'TAP
                 yield self.Error('Too many tests run (expected {}, got {})'.format(plan.count, num_tests))
 
 
-
 class JunitBuilder:
 
     """Builder for Junit test results.
@@ -443,6 +442,28 @@ def write(self) -> None:
             tree.write(f, encoding='utf-8', xml_declaration=True)
 
 
+def parse_rust_test(stdout: str) -> T.Dict[str, TestResult]:
+    """Parse the output of rust tests."""
+    res = {}  # type; T.Dict[str, TestResult]
+
+    def parse_res(res: str) -> TestResult:
+        if res == 'ok':
+            return TestResult.OK
+        elif res == 'ignored':
+            return TestResult.SKIP
+        elif res == 'FAILED':
+            return TestResult.FAIL
+        raise MesonException('Unsupported output from rust test: {}'.format(res))
+
+    for line in stdout.splitlines():
+        if line.startswith('test ') and not line.startswith('test result'):
+            _, name, _, result = line.split(' ')
+            name = name.replace('::', '.')
+            res[name] = parse_res(result)
+
+    return res
+
+
 class TestRun:
 
     @classmethod
@@ -512,6 +533,25 @@ def make_tap(cls, test: TestSerialisation, test_env: T.Dict[str, str],
 
         return cls(test, test_env, res, results, returncode, starttime, duration, stdo, stde, cmd)
 
+    @classmethod
+    def make_rust(cls, test: TestSerialisation, test_env: T.Dict[str, str],
+                  returncode: int, starttime: float, duration: float,
+                  stdo: str, stde: str,
+                  cmd: T.Optional[T.List[str]]) -> 'TestRun':
+        results = parse_rust_test(stdo)
+
+        failed = TestResult.FAIL in results.values()
+        # Now determine the overall result of the test based on the outcome of the subcases
+        if all(t is TestResult.SKIP for t in results.values()):
+            # This includes the case where num_tests is zero
+            res = TestResult.SKIP
+        elif test.should_fail:
+            res = TestResult.EXPECTEDFAIL if failed else TestResult.UNEXPECTEDPASS
+        else:
+            res = TestResult.FAIL if failed else TestResult.OK
+
+        return cls(test, test_env, res, results, returncode, starttime, duration, stdo, stde, cmd)
+
     def __init__(self, test: TestSerialisation, test_env: T.Dict[str, str],
                  res: TestResult, results: T.Dict[str, TestResult], returncode:
                  int, starttime: float, duration: float,
@@ -796,6 +836,8 @@ def _send_signal_to_process_group(pgid : int, signum : int) -> None:
                 return TestRun.make_exitcode(self.test, self.test_env, p.returncode, starttime, duration, stdo, stde, cmd)
             elif self.test.protocol is TestProtocol.GTEST:
                 return TestRun.make_gtest(self.test, self.test_env, p.returncode, starttime, duration, stdo, stde, cmd)
+            elif self.test.protocol is TestProtocol.RUST:
+                return TestRun.make_rust(self.test, self.test_env, p.returncode, starttime, duration, stdo, stde, cmd)
             else:
                 if self.options.verbose:
                     print(stdo, end='')

test cases/rust/9 unit tests/meson.build

@@ -0,0 +1,32 @@
+project('rust unit tests', 'rust')
+
+t = executable(
+  'rust_test',
+  ['test.rs'],
+  rust_args : ['--test'],
+)
+
+test(
+  'rust test (should fail)',
+  t,
+  protocol : 'rust',
+  suite : ['foo'],
+  should_fail : true,
+)
+
+test(
+  'rust test (should pass)',
+  t,
+  args : ['--skip', 'test_add_intentional_fail'],
+  protocol : 'rust',
+  suite : ['foo'],
+)
+
+
+test(
+  'rust test (should skip)',
+  t,
+  args : ['--skip', 'test_add'],
+  protocol : 'rust',
+  suite : ['foo'],
+)

test cases/rust/9 unit tests/test.rs

@@ -0,0 +1,24 @@
+pub fn add(a: i32, b: i32) -> i32 {
+    return a + b;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_add() {
+        assert_eq!(add(1, 2), 3);
+    }
+
+    #[test]
+    fn test_add_intentional_fail() {
+        assert_eq!(add(1, 2), 5);
+    }
+
+    #[test]
+    #[ignore]
+    fn test_add_intentional_fail2() {
+        assert_eq!(add(1, 7), 5);
+    }
+}