Allow build definitions to retrieve the unittest flag of a D compiler

D allows programmers to define their tests alongside the actual code in
a unittest scope[1].
When compiled with a special flag, the compiler will build a binary
containing the tests instead of the actual application.

This is a strightforward and easy way to run tests and works well with
Mesons test() command.

Since using just one flag name to enable unittest mode would be too
boring, compiler developers invented multiple ones.

Adding this helper method makes it easy for people writing Meson build
descriptions for D projects to enable unittestmode.

[1]: https://dlang.org/spec/unittest.html

mesonbuild/compilers.py

@@ -1505,6 +1505,9 @@ class DCompiler(Compiler):
     def get_soname_args(self, shlib_name, path, soversion):
         return []
 
+    def get_unittest_flag(self):
+        return ['-unittest']
+
     def build_rpath_args(self, build_dir, rpath_paths, install_rpath):
         # This method is to be used by LDC and DMD.
         # GDC can deal with the verbatim flags.
@@ -1562,6 +1565,9 @@ class GnuDCompiler(DCompiler):
     def build_rpath_args(self, build_dir, rpath_paths, install_rpath):
         return build_unix_rpath_args(build_dir, rpath_paths, install_rpath)
 
+    def get_unittest_flag(self):
+        return ['-funittest']
+
 class LLVMDCompiler(DCompiler):
     def __init__(self, exelist, version, is_cross):
         DCompiler.__init__(self, exelist, version, is_cross)

mesonbuild/interpreter.py

@@ -597,6 +597,7 @@ class CompilerHolder(InterpreterObject):
                              'find_library': self.find_library_method,
                              'has_argument' : self.has_argument_method,
                              'first_supported_argument' : self.first_supported_argument_method,
+                             'get_unittest_flag' : self.get_unittest_flag_method,
                             })
 
     def version_method(self, args, kwargs):
@@ -650,6 +651,12 @@ class CompilerHolder(InterpreterObject):
     def get_id_method(self, args, kwargs):
         return self.compiler.get_id()
 
+    def get_unittest_flag_method(self, args, kwargs):
+        # At time, only D compilers have this feature.
+        if not getattr(self.compiler, "get_unittest_flag", None):
+            return ''
+        return self.compiler.get_unittest_flag()
+
     def has_member_method(self, args, kwargs):
         if len(args) != 2:
             raise InterpreterException('Has_member takes exactly two arguments.')

test cases/d/4 unittest/app.d

@@ -0,0 +1,34 @@
+
+import std.stdio;
+
+uint getFour ()
+{
+    auto getTwo ()
+    {
+        return 1 + 1;
+    }
+
+    return getTwo () + getTwo ();
+}
+
+void main ()
+{
+    import core.stdc.stdlib : exit;
+
+    writeln ("Four: ", getFour ());
+    exit (4);
+}
+
+unittest
+{
+    writeln ("TEST");
+    import core.stdc.stdlib : exit;
+
+    assert (getFour () > 2);
+    assert (getFour () == 4);
+
+    // we explicitly terminate here to give the unittest program a different exit
+    // code than the main application has.
+    // (this prevents the regular main() from being executed)
+    exit (0);
+}

test cases/d/4 unittest/installed_files.txt

@@ -0,0 +1 @@
+usr/bin/dapp?exe

test cases/d/4 unittest/meson.build

@@ -0,0 +1,8 @@
+project('D Unittests', 'd')
+
+e = executable('dapp', 'app.d', install : true)
+test('dapp_run', e, should_fail: true)
+
+e_test = executable('dapp_test', 'app.d',
+    d_args: meson.get_compiler('d').get_unittest_flag())
+test('dapp_test', e_test)