MUnit Maven Plugin

MUnit provides a Maven plugin that enables you to run your MUnit tests as part of your continuous integration environment.

The following configurations to the pom.xml or settings.xml files of your Maven installation apply only when running Munit through Maven.

Set Up MUnit Maven Plugin

This documentation assumes you have the <munit.version> property in your pom.xml.

Enable the MUnit Maven plugin in your pom.xml file:

MUnit Maven Plugin

<build>
  <plugins>
  ...

    <plugin>
      <groupId>com.mulesoft.munit.tools</groupId>
      <artifactId>munit-maven-plugin</artifactId>
      <version>${munit.version}</version>
      <executions>
        <execution>
          <id>test</id>
          <phase>test</phase>
          <goals>
            <goal>test</goal>
          </goals>
        </execution>
      </executions>
    </plugin>

  ...
  </plugins>
</build>

Add MUnit dependencies to your pom.xml file:

Dependencies

<dependencies>
  ...
  <dependency>
    <groupId>com.mulesoft.munit</groupId>
    <artifactId>munit-runner</artifactId>
    <version>${munit.version}</version>
    <classifier>mule-plugin</classifier>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>com.mulesoft.munit</groupId>
    <artifactId>munit-tools</artifactId>
    <version>${munit.version}</version>
    <classifier>mule-plugin</classifier>
    <scope>test</scope>
  </dependency>
  ...
</dependencies>

Configure the repositories for the MUnit dependencies and plugin:

Repositories

<repositories>
  <repository>
    <id>mulesoft-releases</id>
      <name>MuleSoft Releases Repository</name>
      <url>https://repository.mulesoft.org/releases/</url>
      <layout>default</layout>
    </repository>
</repositories>

Plugin Repositories

<pluginRepositories>
  <pluginRepository>
    <id>mulesoft-release</id>
    <name>mulesoft release repository</name>
    <layout>default</layout>
    <url>https://repository.mulesoft.org/releases/</url>
    <snapshots>
      <enabled>false</enabled>
    </snapshots>
  </pluginRepository>
</pluginRepositories>

MUnit has Surefire support built in. The reports output to target/surefire-reports.

Handle Parent POM Files

You can declare the MUnit plugin in a parent pom.xml file and every child project under this file can reference this definition.

To configure the MUnit Maven plugin in a parent-child POM relationship, include the MUnit plugin declaration in the <pluginManagement> section of your parent pom.xml file.

In the following example, the pirate-pom project declares the MUnit Maven plugin in its plugin management section, which defines a global configuration that each child under this parent can reference, override or even ignore.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.1.0</modelVersion>

    <groupId>org.pirate</groupId>
    <artifactId>pirate-pom</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <properties>
        <munit.version>2.3.0</munit.version>
    </properties>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>com.mulesoft.munit.tools</groupId>
                    <artifactId>munit-maven-plugin</artifactId>
                    <version>${munit.version}</version>
                    <executions>
                        <execution>
                            <id>test</id>
                            <phase>test</phase>
                            <goals>
                                <goal>test</goal>
                            </goals>
                        </execution>
                    </executions>
                    <configuration>
                      <coverage>
                          <runCoverage>true</runCoverage>
                          <failBuild>false</failBuild>
                          <requiredApplicationCoverage>0</requiredApplicationCoverage>
                          <requiredResourceCoverage>0</requiredResourceCoverage>
                          <requiredFlowCoverage>0</requiredFlowCoverage>
                          <formats>
                              <format>console</format>
                              <format>html</format>
                          </formats>
                      </coverage>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

Inherit a Parent Plugin

To inherit the MUnit plugin in your child pom.xml files, reference it in the <plugin> section of each child POM file individually.

The following sample references pirate-pom file as its parent and then declares the MUnit plugin in a <plugin> section without specifying its <version> because the MUnit plugin configuration is inherited from the <pluginManagement> section in the parent POM file:

POM child file sample

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

    <parent>
        <groupId>org.pirate</groupId>
        <artifactId>pirate-pom</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany</groupId>
    <artifactId>ninja</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>mule</packaging>
    <name>Mule ninja Application</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <app.runtime>4.1.4</app.runtime>
        <munit.version>2.3.0</munit.version>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>com.mulesoft.munit.tools</groupId>
                <artifactId>munit-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

Ignore a Parent Plugin

Each child project under a parent pom.xml file can ignore the plugin referenced in the parent plugin management section and not implement the plugin configuration declared there.

By not declaring the Munit Plugin in your <plugin> section, you avoid inheriting the plugin declared in pirate-pom:

Child POM file not inheriting the MUnit Maven Plugin

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

    <parent>
        <groupId>org.pirate</groupId>
        <artifactId>pirate-pom</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany</groupId>
    <artifactId>ninja</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>mule</packaging>
    <name>Mule ninja Application</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <mule.version>4.1.0</mule.version>
        <munit.version>2.3.0</munit.version>
    </properties>

    <build>
        <plugins>
            <plugin>
            </plugin>
        </plugins>
    </build>
</project>

Override a Parent Plugin

When inheriting the plugin from a parent POM file, you can also override the parent configuration. Overriding the plugin configuration from your parent POM file suppresses the original configuration requiring you to declare all necessary configurations again.

The following example overrides the console coverage report from its parent POM file, replacing it by the HTML report. Because the values from the other elements in the parent (<failBuild>, <requiredApplicationCoverage>, <requiredResourceCoverage>, <requiredFlowCoverage>) are not being referenced, this child file won’t inherit them and the default values will apply:

Coverage configuration in parent POM file

<coverage>
	<runCoverage>true</runCoverage>
	<failBuild>false</failBuild>
	<requiredApplicationCoverage>0</requiredApplicationCoverage>
	<requiredResourceCoverage>0</requiredResourceCoverage>
	<requiredFlowCoverage>0</requiredFlowCoverage>
	<formats>
		<format>console</format>
		<format>html</format>
	</formats>
</coverage>

POM child file overriding coverage report’s format

<plugin>
	<groupId>com.mulesoft.munit.tools</groupId>
	<artifactId>munit-maven-plugin</artifactId>
	<configuration>
		<coverage>
			<runCoverage>true</runCoverage>
			<formats>
				<format>html</format>
			</formats>
		</coverage>
	</configuration>
</plugin>

Set Up Coverage

The following configurations only apply when you execute your MUnit tests using the Maven plugin. They do not apply when running tests from Studio. See Using Coverage in Maven for more information.

Since MUnit 2.x, the coverage report goal is integrated with the maven reporting section. Coverage Reports are generated during Maven’s site lifecycle, during the coverage-report goal.

The following configurations apply only when you execute your MUnit tests using the Maven plugin. They do not apply when running tests from Studio.
To run coverage reports in Studio see Using Coverage in Studio.

MUnit Coverage - Sample Maven configuration

<plugin>
    <groupId>com.mulesoft.munit.tools</groupId>
    <artifactId>munit-maven-plugin</artifactId>
    <version>${munit.version}</version>

    <executions>
        <execution>
            <id>test</id>
            <phase>test</phase>
            <goals>
                <goal>test</goal>
                <goal>coverage-report</goal>
            </goals>
        </execution>
    </executions>

    <configuration>
        <coverage>
            <runCoverage>true</runCoverage>
            <failBuild>false</failBuild>

            <requiredApplicationCoverage>75</requiredApplicationCoverage>
            <requiredResourceCoverage>50</requiredResourceCoverage>
            <requiredFlowCoverage>50</requiredFlowCoverage>

            <formats>
                <format>console</format>
                <format>html</format>
            </formats>
        </coverage>
    </configuration>
</plugin>

Set up a Minimum Coverage Level

One of the features of MUnit Coverage is to fail the build if a certain coverage level is not reached.

MUnit Coverage handles three different levels:

Application: The overall coverage of all your application.
Resource: The coverage level of each individual Mule configuration file.
Flow: The coverage of event processors in each flow.

To define the required coverage levels:

MUnit Coverage - Require Coverage

<coverage>
    <runCoverage>true</runCoverage>
    <failBuild>true</failBuild>

    <requiredApplicationCoverage>75</requiredApplicationCoverage> (1)
    <requiredResourceCoverage>50</requiredResourceCoverage>
    <requiredFlowCoverage>50</requiredFlowCoverage>
</coverage>

1	Each value represents a percentage. If a percentage is not defined, it defaults to -1, which indicates that no requirements are defined for said level so the build will not fail due to low coverage.

If you define coverage levels but set the property failBuild to false, and then the levels are not reached, a warning shows up in the MUnit coverage summary:

===============================================================================
MUnit Coverage Summary
===============================================================================
 * Resources: 2 - Flows: 3 - Processors: 4
 * Application Coverage: 75.00%

----------------------------- WARNING --------------------------------------
 * Flow: file2.xml -> file2Flow1 coverage is below defined limit. Required: 50.0% - Current: 00.00% (1)
====================================================================================

1	Warning detailing which coverage level was not met, and where it happened.

Ignore a flow or a file

Another feature is the ability to ignore either a flow or a file. This way, the ignored resource:

Does not count as coverage data.
Does not affect the overall number of message processors.
Does not cause a build to fail if the flow is not tested or if the flow does not reach coverage metrics.

To ignore flows and files:

MUnit Coverage - Ignore both flows and files

<coverage>
    <runCoverage>true</runCoverage>
    <failBuild>true</failBuild>

    <requiredApplicationCoverage>100</requiredApplicationCoverage>
    <requiredResourceCoverage>100</requiredResourceCoverage>
    <requiredFlowCoverage>100</requiredFlowCoverage>

    <ignoreFlows>
        <ignoreFlow>flow-1</ignoreFlow>
        <ignoreFlow>flow-2</ignoreFlow>
        ...
        <ignoreFlow>flow-n</ignoreFlow>
    </ignoreFlows>

    <ignoreFiles>
        <ignoreFile>mule-config-1.xml</ignoreFile>
        <ignoreFile>mule-config-2.xml</ignoreFile>
        ...
        <ignoreFile>mule-config-n.xml</ignoreFile>
    </ignoreFiles>
</coverage>

Dynamic Ports

MUnit 2.2 and later introduce the dynamic-port global element, that allows you to define dynamic ports at the MUnit suite level. Using this element instead of the plugin configuration described as follows allows you to set the dynamic port both from Maven and Studio.
See Dynamic Ports to learn how to configure this element.

When testing a Mule application in a continuous integration (CI) environment, you might encounter the following scenario:

Your application tries to open a specific port. The port is already in use. The application fails with a port binding exception.

The MUnit Maven Plugin comes with a built-in feature to make your application use a free port.

MUnit Dynamic Ports instructs the MUnit Maven Plugin to look for unbound ports and reserve them before running the tests over the Mule application. Each port selected is placed in a system property under the name indicated in the configuration. The application can acquire the port number through the use of placeholders afterward.

The Ports to be selected by the plugin are taken from the range: [40000,50000]

Dynamic Ports feature is only available as part of the MUnit Maven Plugin. This feature does not work when running tests from inside Anypoint Studio.

Enable Dynamic Ports

To enable the feature, you need to add the following code to the configuration section of the MUnit Maven Plugin:

Dynamic Ports Configuration

<plugins>
  <plugin>
    <groupId>com.mulesoft.munit.tools</groupId>
    <artifactId>munit-maven-plugin</artifactId>
    <configuration>
    ...
    <dynamicPorts>
      <dynamicPort>a.dynamic.port</dynamicPort>
    </dynamicPorts>
    ...
    </configuration>
  </plugin>
</plugins>

If you have the ${http.port} placeholder in your application, the configuration looks something like:

Example

<dynamicPorts>
  <dynamicPort>http.port</dynamicPort>
</dynamicPorts>

Prepare Your Application

A placeholder must parameterize the part of the application trying to make use of a port. For example, to have your Mule application listening for HTTP traffic, provide the following configuration:

HTTP Application

<http:listener-config name="HTTP_Listener_config">
  <http:listener-connection host="0.0.0.0" port="8081" />
</http:listener-config>

<flow name="httpFlow">
  <http:listener path="/" config-ref="HTTP_Listener_config"/>
</flow>

The previous application always listens in port 8081. To make it dynamic, change it to:

HTTP Application with dynamic port

<http:listener-config name="HTTP_Listener_config">
  <http:listener-connection host="0.0.0.0" port="${http.port}"/> (1)
</http:listener-config>

<flow name="httpFlow">
  <http:listener path="/" config-ref="HTTP_Listener_config"/>
</flow>

1	Notice the placeholder `${http.port}`.

With the application coded in this way and the configuration of Dynamic Ports in place, your application starts each run listening on a different port.

Enable Surefire Reports

MUnit has built-in support for Surefire. No additional configuration is needed, but you can disable it if you don’t need it:

Disable surefire reports

<enableSurefireReports>false</enableSurefireReports>

The reports can be found under ${project.build.directory}/surefire-reports.

By default, it is set to true.

Enable Sonar Reports

MUnit has built-in support for SonarQube, with a default setting of true for enableSonarReports. No additional configuration is needed.

You can find the reports under ${project.build.directory}/sonar-reports.

You can disable SONAR reports if you don’t need them:

Disable sonar reports

<enableSonarReports>false</enableSonarReports>

The reports can be found under ${project.build.directory}/sonar-reports.

By default, it is set to true.

Run Tests Using the Plugin

Run MUnit Tests for a Mule Application

Run MUnit tests in a Single Resource Mule project.

mvn clean test

Run a Specific MUnit Test Suite

By using the property munit.test, you can instruct the MUnit Maven plugin to run only tests that belong to a specific test suite:

mvn clean test -Dmunit.test=<regex-test-suite>

This path is relative to src/test/munit.

The property munit.test accepts regular expressions. The expression is applied to the name of the MUnit Test Suite file. The regular expression language is the Java implementation.

For example:

mvn clean test -Dmunit.test=.*my-test.*

You can leverage this feature by adding naming conventions to your MUnit Test suites.

Run Specific MUnit Tests

In the same way that you instruct MUnit to run one test suite, you can also configure it to run a specific test inside that test suite. You must use the property munit.test with the addition of the the special character # to append the test name:

mvn clean test -Dmunit.test=<regex-test-suite>#<regex-test-name>

It also accepts regular expressions. The expression is applied to the attribute name of the MUnit Test. For example:

mvn clean test -Dmunit.test=.*my-test.*#.*test-scenario-1.*

The tests inside the MUnit Test Suite that don’t match the regular expression are flagged as ignored.

You can also configure this from the pom.xml configuration:

<plugins>
  <plugin>
      <groupId>com.mulesoft.munit.tools</groupId>
      <artifactId>munit-maven-plugin</artifactId>
      <configuration>
      ...
      <munitTest>example-MunitTest-suite.xml</munitTest>
      ...
    </configuration>
  </plugin>
</plugins>

Run Tests Using a Specific Tag

You can run only the tests that you grouped under one specific tag:

mvn clean test -Dmunit.tags=<munit-tag>

You can also configure this from the pom.xml configuration:

<plugins>
  <plugin>
      <groupId>com.mulesoft.munit.tools</groupId>
      <artifactId>munit-maven-plugin</artifactId>
      <configuration>
      ...
      <munitTags>exampleMunitTag</munitTags>
      ...
    </configuration>
  </plugin>
</plugins>

You can specify more than one tag by separating them using a comma.

Skip All Tests

MUnit leverages the same mechanism as Maven. To skip tests, you must use the skipTests parameter:

Skip Tests example

mvn clean package -DskipTests

You can also configure this from the pom.xml configuration:

<plugins>
  <plugin>
      <groupId>com.mulesoft.munit.tools</groupId>
      <artifactId>munit-maven-plugin</artifactId>
      <configuration>
      ...
      <skipMunitTests>true</skipMunitTests>
      ...
    </configuration>
  </plugin>
</plugins>

Skip Tests After One Suite Fails

MUnit allows you to skip the rest of the tests if one test suite fails:

<plugins>
  <plugin>
      <groupId>com.mulesoft.munit.tools</groupId>
      <artifactId>munit-maven-plugin</artifactId>
      <configuration>
      ...
      <skipAfterFailure>true</skipAfterFailure>
      ...
    </configuration>
  </plugin>
</plugins>

If not specified, this value is false by default.

Specify The Runtime Product

You can specify the type of runtime in which your applications being tested will run. Accepted values are:

MULE for community edition.
MULE_EE for enterprise edition.

<plugins>
  <plugin>
    <groupId>com.mulesoft.munit.tools</groupId>
    <artifactId>munit-maven-plugin</artifactId>
    <configuration>
      ...
      <runtimeProduct>MULE</runtimeProduct>
      ...
    </configuration>
  </plugin>
</plugins>

Specify the Runtime Product Version

MUnit allows you to specify the runtime version in which your applications being tested will run.

<plugins>
  <plugin>
    <groupId>com.mulesoft.munit.tools</groupId>
    <artifactId>munit-maven-plugin</artifactId>
    <configuration>
      ...
      <runtimeVersion>4.2.2</runtimeVersion>
      ...
    </configuration>
  </plugin>
</plugins>

Specify The JVM

You can specify the JVM (or the java executable) in which your applications being tested run. You must populate the munit.jvm parameter with the path to the executable:

Specify the JVM

mvn clean package -Dmunit.jvm=/path/to/jdk/bin/java

You can also configure this from the pom.xml configuration:

<plugins>
  <plugin>
    <groupId>com.mulesoft.munit.tools</groupId>
    <artifactId>munit-maven-plugin</artifactId>
    <configuration>
      ...
      <jvm>/path/to/jdk/bin/java</jvm>
      ...
    </configuration>
  </plugin>
</plugins>

Additional Argument Lines

You can pass additional argument lines to the JVM. Specify each argument in a separate argLine:

Argument lines

<plugins>
  <plugin>
    <groupId>com.mulesoft.munit.tools</groupId>
    <artifactId>munit-maven-plugin</artifactId>
    <configuration>
      ...
      <argLines>
          <argLine>-XX:MaxPermSize=512m</argLine>
          <argLine>-Xmx1024m</argLine>
      </argLines>
      ...
    </configuration>
  </plugin>
</plugins>

Environment Variables

To set additional environment variables during the test run, you can specify them with the respective key and value:

Additional Environment Variables

<plugins>
  <plugin>
    <groupId>com.mulesoft.munit.tools</groupId>
    <artifactId>munit-maven-plugin</artifactId>
    <configuration>
      ...
      <environmentVariables>
        <MY_ENV>exampleValue</MY_ENV>
        <MY_OTHER_ENV>val2</MY_OTHER_ENV>
      </environmentVariables>
      ...
    </configuration>
  </plugin>
</plugins>

As shown in the previous example, you can use environment variables to replace placeholders such as ${MY_ENV}.

System Properties Variables

You may need to define specific system variables so that your MUnit test runs successfully:

Setting system property variables

<plugins>
  <plugin>
    <groupId>com.mulesoft.munit.tools</groupId>
    <artifactId>munit-maven-plugin</artifactId>
    <configuration>
      ...
      <systemPropertyVariables>
        <my.property.key>my.property.value</my.property.key>
      </systemPropertyVariables>
      ...
    </configuration>
  </plugin>
</plugins>

Depending on the execution context, the system properties values may vary. When referencing these properties, it is a good practice to override their value to enforce test reproducibility.

You can do so using the -D argument when running MUnit with Maven. Variables passed with the -D argument take full priority over any other property. For example:

-Dmy.property.key=my.property.another.value

Redirect Test Output to File

When running several tests, the build output can get very complex to read. MUnit allows you to redirect the output of each test suite to a file. This way, only the test results will remain in the build output and to you can check the respective file to check the standard output of each test suite.

These files are located in the testOutputDirectory folder following the naming convention: munit.${suiteName}-output.txt, where the suiteName represents the name of the XML file relative to the MUnit test folder.

The test’s output that doesn’t belong to a particular suite won’t be printed to keep the build output clean, but it can be enabled by running maven in debug mode.

To redirect the output of each test suite to a file:

Redirect test output to file

<plugins>
  <plugin>
    <groupId>com.mulesoft.munit.tools</groupId>
    <artifactId>munit-maven-plugin</artifactId>
    <configuration>
      ...
      <redirectTestOutputToFile>true</redirectTestOutputToFile>
      ...
    </configuration>
  </plugin>
</plugins>

By default, it is set to false

Test Output Directory

You may want to choose the location where the test output files will be created. The path specified can be absolute or written as a Maven placeholder:

Test output directory with absolute path

<plugins>
  <plugin>
    <groupId>com.mulesoft.munit.tools</groupId>
    <artifactId>munit-maven-plugin</artifactId>
    <configuration>
      ...
      <testOutputDirectory>/my/absolute/path</testOutputDirectory>
      ...
    </configuration>
  </plugin>
</plugins>

Test output directory using maven placeholders

<testOutputDirectory>${project.build.directory}/my/output/folder</testOutputDirectory>

By default, the files are created in ${project.build.directory}/munit-reports/output/.

MUnit Maven Plugin Configuration Reference

The MUnit Maven Plugin offers a set of optional parameters that can be configured.

Table 1. Maven Plugin Parameters
Name	Type	Description
`argLines`	List	Additional JVM argument lines to set on the test run.
`coverage`	Configuration	Coverage configuration to be set on the test run.
`dynamicPorts`	List	Dynamic ports to be set on the test run.
`enableSurefireReports`	boolean	Set value to `true` to generate MUnit test results in the surefire format. Default value: `true`
`munitTest`	String	Name of the MUnit tests to run.
`munitTags`	String	Name of the MUnit tags. Only tests tagged with these names will run.
`skipMunitTests`	boolean	Set to `true` when you want to skip all MUnit tests. Default value: `false`
`skipAfterFailure`	boolean	Skip all tests if one fails. Default value: `false`
`munitTestsDirectory`	File	Directory where the MUnit tests reside. Default value: `${project.build.directory}/test-mule/munit`
`runtimeVersion`	String	Version of the Mule runtime When you run your tests from Maven, this value is taken from the `minMuleVersion` parameter in the `mule-artifact.json` file. To modify the Mule runtime version used to run your MUnit tests in Studio, see Runtime Patching in Studio.
runtimeProduct	String	Type of runtime. Expected values are: `MULE` for community edition `MULE_EE` for enterprise edition. By default, this value is taken from the `requiredProduct` parameter in the `mule-artifact.json` file.
`jvm`	String	Option to specify the JVM (or path to the java executable) to use. By default, the JVM will the same VM as the one used to run Maven.
`environmentVariables`	Map	Additional environment variables to be set on the test run.
`redirectTestOutputToFile`	boolean	Set value to `true` to redirect the MUnit tests standard output to a file. Default value: `false`
`systemPropertyVariables`	Map	System properties to be set on the test run.
`testOutputDirectory`	File	Directory where the test outputs will be written to. Default value: `${project.build.directory}/munit-reports/output/`