plugins/maven-test-plugin/src/main/java/npanday/plugin/test/TesterMojo.java - npanday - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 package npanday.plugin.test;

 import npanday.ArtifactTypeHelper;
 import npanday.LocalRepositoryUtil;
 import npanday.PathUtil;
 import npanday.PlatformUnsupportedException;
 import npanday.executable.CommandExecutor;
 import npanday.executable.ExecutableRequirement;
 import npanday.executable.ExecutionException;
 import npanday.executable.NetExecutable;
 import npanday.executable.NetExecutableFactory;
 import npanday.registry.RepositoryRegistry;
 import npanday.resolver.NPandayDependencyResolution;
 import npanday.resolver.filter.DotnetAssemblyArtifactFilter;
 import npanday.resolver.filter.DotnetSymbolsArtifactFilter;
 import npanday.resolver.filter.OrArtifactFilter;
 import npanday.vendor.SettingsUtil;
 import npanday.vendor.StateMachineProcessor;
 import npanday.vendor.Vendor;
 import npanday.vendor.VendorInfo;
 import npanday.vendor.VendorRequirement;
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.artifact.resolver.ArtifactResolutionException;
 import org.apache.maven.artifact.resolver.filter.AndArtifactFilter;
 import org.apache.maven.artifact.resolver.filter.InversionArtifactFilter;
 import org.apache.maven.artifact.resolver.filter.ScopeArtifactFilter;
 import org.apache.maven.plugin.AbstractMojo;
 import org.apache.maven.plugin.MojoExecutionException;
 import org.apache.maven.plugin.MojoFailureException;
 import org.apache.maven.plugin.logging.Log;
 import org.apache.maven.project.MavenProject;
 import org.codehaus.plexus.logging.Logger;
 import org.codehaus.plexus.util.FileUtils;

 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;

 import static com.google.common.base.Strings.isNullOrEmpty;

 /**
  * Runs NUnit tests
  *
  * @author Shane Isbell
  * @goal test
  * @phase test
  * @description Runs NUnit tests
  */
 public class TesterMojo
     extends AbstractTestrelatedMojo
 {
     /**
      * The home of nunit. Use this if you 1) have not added nunit to your path and you only have MS installed; or 2)
      * have mono installed and want to use another version of nunit.
      *
      * @parameter
      */
     private String nunitHome;

     /**
      * Display XML to the console
      *
      * @parameter expression = "${xmlConsole}" default-value = "false"
      */
     private boolean xmlConsole;

     /**
      * On 64bit-systems, the tests will automatically perform in .NET 64bit-version. If you need to
      * run your tests using 32bit (native calls, i.e.) set this option to true.
      * @parameter default-value = "false"
      */
     private boolean forceX86;

     /**
      * Skips unit test
      *
      * @parameter expression = "${skipTests}" default-value = "false"
      */
     private boolean skipTest;

     /**
      * Directory where reports are written.
      *
      * @parameter expression = "${reportsDirectory}" default-value = "${project.build.directory}/nunit-reports"
      */
     private String reportsDirectory;

     /**
      * nUnitXmlFilePath
      *
      * @parameter default-value = "${project.build.directory}/nunit-reports/TEST-${project.build.finalName}.xml"
      * @required
      */
     private File nUnitXmlFilePath;

     /**
      * nUnitResultOutputPath
      *
      * @parameter default-value = "${project.build.directory}/nunit-reports/TEST-${project.build.finalName}-RESULTS.txt"
      * @required
      */
     private File nUnitResultOutputPath;

     /**
      * nUnitResultErrorOutputPath
      *
      * @parameter default-value = "${project.build.directory}/nunit-reports/TEST-${project.build.finalName}-ERROR.txt"
      * @required
      */
     private File nUnitResultErrorOutputPath;

     /**
      * @component
      */
     private StateMachineProcessor processor;

     /**
      * Specify the name of the NUnit command to be run, from within the <i>nunitHome</i>/bin directory.
      *
      * @parameter
      * @deprecated since 1.5.0-incubating
      */
     private String nunitCommand;

     /**
      * The framework version to run the tests: 1.1, 2.0, 3.5, 4.0. Note that using this setting will require you to use
      * NUnit >= 2.5.
      *
      * @parameter expression = "${executionFrameworkVersion}"
      */
     private String executionFrameworkVersion;

     /**
      * @component
      */
     private NPandayDependencyResolution dependencyResolution;

     /**
      * Specifies if debug symbols for all dependencies should be resolved and copied to the test directory.
      *
      * @parameter expression = "${test.resolvePdbs}" default-value="true"
      */
     private Boolean resolvePdbs;


     private File getExecutableHome()
     {
         return (nunitHome != null) ? new File(nunitHome, "bin") : null;
     }

     private List<String> getCommandsFor( )
     {
         String finalName = project.getBuild().getFinalName();
         List<String> commands = new ArrayList<String>();
         if ( testAssemblyPath.startsWith( "/" ) ) // nunit-console thinks *nix file format /home/user/ is an option
                                                   // due to / and fails.
         {
             testAssemblyPath = "/" + testAssemblyPath;
         }

         commands.add( testAssemblyPath + File.separator + getTestFileName() );

         String switchChar = "-";
         commands.add( switchChar + "xml:" + nUnitXmlFilePath.getAbsolutePath() );

         commands.add( switchChar + "output:" + nUnitResultOutputPath.getAbsolutePath() );
         commands.add( switchChar + "err:" + nUnitResultErrorOutputPath.getAbsolutePath() );

         commands.add( switchChar + "labels" );

         if ( xmlConsole )
         {
             commands.add( switchChar + "xmlConsole" );
         }

         // Not supported on NUnit < 2.5 - see NPANDAY-332
         if ( executionFrameworkVersion != null && executionFrameworkVersion.length() > 0 )
         {
             getLog().debug( "NPANDAY-1100-012: Framework version:" + executionFrameworkVersion );
             commands.add( switchChar + "framework:" + "v" + executionFrameworkVersion );
         }

         return commands;
     }

     @Override
     protected void innerExecute() throws MojoExecutionException, MojoFailureException
     {
         String skipTests = System.getProperty( "maven.test.skip" );
         if ( ( skipTests != null && skipTests.equalsIgnoreCase( "true" ) ) || skipTest )
         {
             getLog().warn( "NPANDAY-1100-000: Unit tests have been disabled." );
             return;
         }

         super.innerExecute();

         String testFileName = "";
         String pdbTestFileName = "";

         if(integrationTest)
         {
             getLog().info("NPANDAY-1100-000.1: Artifact is an Integration Test");
             testFileName = project.getBuild().getDirectory() + File.separator + project.getArtifactId() + ".dll";
             pdbTestFileName = project.getBuild().getDirectory() + File.separator + project.getArtifactId() + ".pdb";
         }
         else
         {
             testFileName = project.getBuild().getDirectory() + File.separator + project.getArtifactId() + "-test.dll";
             pdbTestFileName = project.getBuild().getDirectory() + File.separator + project.getArtifactId() + "-test.pdb";
         }

         if ( !( new File( testFileName ).exists() ) )
         {
             getLog().info( "NPANDAY-1100-001: No Unit Tests" );
             return;
         }

         Set<Artifact> artifacts;
         try
         {
             AndArtifactFilter filter = new AndArtifactFilter();
             filter.add(new ScopeArtifactFilter("test"));

             if (!resolvePdbs){
               filter.add(new InversionArtifactFilter(new DotnetSymbolsArtifactFilter()));
             }

             artifacts = dependencyResolution.require(
                 project, LocalRepositoryUtil.create( localRepository ), filter
             );
         }
         catch ( ArtifactResolutionException e )
         {
             throw new MojoExecutionException(
                 "NPANDAY-1100-009: dependency resolution for scope test failed!", e
             );
         }

         for ( Artifact artifact : artifacts )
         {
             if ( ArtifactTypeHelper.isDotnetAnyGac( artifact.getType() ) )
             {
                 continue;
             }

             try
             {
                 PathUtil.copyPlainArtifactFileToDirectory( artifact, new File( testAssemblyPath ) );
             }
             catch ( IOException e )
             {
                 throw new MojoExecutionException( "NPANDAY-1100-002: Error on copying artifact " + artifact, e );
             }
         }

         try
         {
             if ( project.getArtifact() != null && project.getArtifact().getFile() != null
                 && project.getArtifact().getFile().exists() )
             {
                 FileUtils.copyFileToDirectory( project.getArtifact().getFile(), new File( testAssemblyPath ) );
             }
         }
         catch ( IOException e )
         {
             throw new MojoExecutionException( "NPANDAY-1100-004: Unable to copy library to target directory: ", e );
         }

         try
         {
             FileUtils.copyFileToDirectory( new File( testFileName ), new File( testAssemblyPath ) );
             File pdbTestFile = new File( pdbTestFileName );
             if ( pdbTestFile.exists() )
             {
                 FileUtils.copyFileToDirectory( pdbTestFile, new File( testAssemblyPath ) );
             }
         }
         catch ( IOException e )
         {
             throw new MojoExecutionException( "NPANDAY-1100-005: Unable to copy library to target directory: ", e );
         }

         FileUtils.mkdir( reportsDirectory );


         List<String> commands = getCommandsFor( );

         // pretty print nunit logs
         getLog().info( System.getProperty( "line.separator" ) );

         File executableHome = getExecutableHome();

         VendorRequirement vendorRequirement = new VendorRequirement( vendor, vendorVersion, executionFrameworkVersion );

         VendorInfo vendorInfo;
         try
         {
             vendorInfo = processor.process( vendorRequirement );
         }
         catch ( npanday.vendor.IllegalStateException e )
         {
             throw new MojoExecutionException(
                 "NPANDAY-902-008: Illegal state of vendor info: Message =  " + e.getMessage(), e);
         }
         catch ( PlatformUnsupportedException e )
         {
             throw new MojoExecutionException(
                 "NPANDAY-902-009: Platform is unsupported: Message =  " + e.getMessage(), e);
         }

         String profile = "NUNIT";
         if ( !vendorInfo.getVendor().equals( Vendor.MONO ) && forceX86 )
         {
             profile = "NUNIT-x86";
         }

         try
         {
             try
             {
                 NetExecutable executable = netExecutableFactory.getExecutable(
                     new ExecutableRequirement( vendorRequirement, profile ), commands,
                     executableHome
                 );

                 executable.execute();
             }
             catch (PlatformUnsupportedException pue)
             {
                 if (isNullOrEmpty(nunitCommand))
                 {
                     throw new MojoExecutionException( "NPANDAY-1100-008: Unsupported Platform.", pue );
                 }

                 // TODO: This should rather be done through a configurable local executable-plugins.xml; then remove nunitcommand
                 getLog().debug( "NPANDAY-1100-008: Platform unsupported, is your npanday-settings.xml configured correctly?", pue );
                 CommandExecutor commandExecutor = CommandExecutor.Factory.createDefaultCommmandExecutor(null);
                 commandExecutor.setLogger( new org.codehaus.plexus.logging.AbstractLogger( 0, "nunit-logger" )
                 {
                     Log log = getLog();

                     public void debug( String message, Throwable throwable )
                     {
                         log.debug( message, throwable );
                     }

                     public void error( String message, Throwable throwable )
                     {
                         log.error( message, throwable );
                     }

                     public void fatalError( String message, Throwable throwable )
                     {
                         log.error( message, throwable );
                     }

                     public Logger getChildLogger( String message )
                     {
                         return null;
                     }

                     public void info( String message, Throwable throwable )
                     {
                         log.info( message, throwable );
                     }

                     public void warn( String message, Throwable throwable )
                     {
                         log.warn( message, throwable );
                     }
                 } );

                 String executablePath = (executableHome != null) ? new File(executableHome, nunitCommand).toString() : nunitCommand;
                 commandExecutor.executeCommand( executablePath, commands );
             }
         }
         catch ( ExecutionException e )
         {
             String line = System.getProperty( "line.separator" );
             throw new MojoFailureException( "NPANDAY-1100-007: There are test failures." + line + line + e.getMessage(), e);
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	package npanday.plugin.test;

	import npanday.ArtifactTypeHelper;
	import npanday.LocalRepositoryUtil;
	import npanday.PathUtil;
	import npanday.PlatformUnsupportedException;
	import npanday.executable.CommandExecutor;
	import npanday.executable.ExecutableRequirement;
	import npanday.executable.ExecutionException;
	import npanday.executable.NetExecutable;
	import npanday.executable.NetExecutableFactory;
	import npanday.registry.RepositoryRegistry;
	import npanday.resolver.NPandayDependencyResolution;
	import npanday.resolver.filter.DotnetAssemblyArtifactFilter;
	import npanday.resolver.filter.DotnetSymbolsArtifactFilter;
	import npanday.resolver.filter.OrArtifactFilter;
	import npanday.vendor.SettingsUtil;
	import npanday.vendor.StateMachineProcessor;
	import npanday.vendor.Vendor;
	import npanday.vendor.VendorInfo;
	import npanday.vendor.VendorRequirement;
	import org.apache.maven.artifact.Artifact;
	import org.apache.maven.artifact.resolver.ArtifactResolutionException;
	import org.apache.maven.artifact.resolver.filter.AndArtifactFilter;
	import org.apache.maven.artifact.resolver.filter.InversionArtifactFilter;
	import org.apache.maven.artifact.resolver.filter.ScopeArtifactFilter;
	import org.apache.maven.plugin.AbstractMojo;
	import org.apache.maven.plugin.MojoExecutionException;
	import org.apache.maven.plugin.MojoFailureException;
	import org.apache.maven.plugin.logging.Log;
	import org.apache.maven.project.MavenProject;
	import org.codehaus.plexus.logging.Logger;
	import org.codehaus.plexus.util.FileUtils;

	import java.io.File;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.Set;

	import static com.google.common.base.Strings.isNullOrEmpty;

	/**
	* Runs NUnit tests
	*
	* @author Shane Isbell
	* @goal test
	* @phase test
	* @description Runs NUnit tests
	*/
	public class TesterMojo
	extends AbstractTestrelatedMojo
	{
	/**
	* The home of nunit. Use this if you 1) have not added nunit to your path and you only have MS installed; or 2)
	* have mono installed and want to use another version of nunit.
	*
	* @parameter
	*/
	private String nunitHome;

	/**
	* Display XML to the console
	*
	* @parameter expression = "${xmlConsole}" default-value = "false"
	*/
	private boolean xmlConsole;

	/**
	* On 64bit-systems, the tests will automatically perform in .NET 64bit-version. If you need to
	* run your tests using 32bit (native calls, i.e.) set this option to true.
	* @parameter default-value = "false"
	*/
	private boolean forceX86;

	/**
	* Skips unit test
	*
	* @parameter expression = "${skipTests}" default-value = "false"
	*/
	private boolean skipTest;

	/**
	* Directory where reports are written.
	*
	* @parameter expression = "${reportsDirectory}" default-value = "${project.build.directory}/nunit-reports"
	*/
	private String reportsDirectory;

	/**
	* nUnitXmlFilePath
	*
	* @parameter default-value = "${project.build.directory}/nunit-reports/TEST-${project.build.finalName}.xml"
	* @required
	*/
	private File nUnitXmlFilePath;

	/**
	* nUnitResultOutputPath
	*
	* @parameter default-value = "${project.build.directory}/nunit-reports/TEST-${project.build.finalName}-RESULTS.txt"
	* @required
	*/
	private File nUnitResultOutputPath;

	/**
	* nUnitResultErrorOutputPath
	*
	* @parameter default-value = "${project.build.directory}/nunit-reports/TEST-${project.build.finalName}-ERROR.txt"
	* @required
	*/
	private File nUnitResultErrorOutputPath;

	/**
	* @component
	*/
	private StateMachineProcessor processor;

	/**
	* Specify the name of the NUnit command to be run, from within the <i>nunitHome</i>/bin directory.
	*
	* @parameter
	* @deprecated since 1.5.0-incubating
	*/
	private String nunitCommand;

	/**
	* The framework version to run the tests: 1.1, 2.0, 3.5, 4.0. Note that using this setting will require you to use
	* NUnit >= 2.5.
	*
	* @parameter expression = "${executionFrameworkVersion}"
	*/
	private String executionFrameworkVersion;

	/**
	* @component
	*/
	private NPandayDependencyResolution dependencyResolution;

	/**
	* Specifies if debug symbols for all dependencies should be resolved and copied to the test directory.
	*
	* @parameter expression = "${test.resolvePdbs}" default-value="true"
	*/
	private Boolean resolvePdbs;


	private File getExecutableHome()
	{
	return (nunitHome != null) ? new File(nunitHome, "bin") : null;
	}

	private List<String> getCommandsFor( )
	{
	String finalName = project.getBuild().getFinalName();
	List<String> commands = new ArrayList<String>();
	if ( testAssemblyPath.startsWith( "/" ) ) // nunit-console thinks *nix file format /home/user/ is an option
	// due to / and fails.
	{
	testAssemblyPath = "/" + testAssemblyPath;
	}

	commands.add( testAssemblyPath + File.separator + getTestFileName() );

	String switchChar = "-";
	commands.add( switchChar + "xml:" + nUnitXmlFilePath.getAbsolutePath() );

	commands.add( switchChar + "output:" + nUnitResultOutputPath.getAbsolutePath() );
	commands.add( switchChar + "err:" + nUnitResultErrorOutputPath.getAbsolutePath() );

	commands.add( switchChar + "labels" );

	if ( xmlConsole )
	{
	commands.add( switchChar + "xmlConsole" );
	}

	// Not supported on NUnit < 2.5 - see NPANDAY-332
	if ( executionFrameworkVersion != null && executionFrameworkVersion.length() > 0 )
	{
	getLog().debug( "NPANDAY-1100-012: Framework version:" + executionFrameworkVersion );
	commands.add( switchChar + "framework:" + "v" + executionFrameworkVersion );
	}

	return commands;
	}

	@Override
	protected void innerExecute() throws MojoExecutionException, MojoFailureException
	{
	String skipTests = System.getProperty( "maven.test.skip" );
	if ( ( skipTests != null && skipTests.equalsIgnoreCase( "true" ) ) \|\| skipTest )
	{
	getLog().warn( "NPANDAY-1100-000: Unit tests have been disabled." );
	return;
	}

	super.innerExecute();

	String testFileName = "";
	String pdbTestFileName = "";

	if(integrationTest)
	{
	getLog().info("NPANDAY-1100-000.1: Artifact is an Integration Test");
	testFileName = project.getBuild().getDirectory() + File.separator + project.getArtifactId() + ".dll";
	pdbTestFileName = project.getBuild().getDirectory() + File.separator + project.getArtifactId() + ".pdb";
	}
	else
	{
	testFileName = project.getBuild().getDirectory() + File.separator + project.getArtifactId() + "-test.dll";
	pdbTestFileName = project.getBuild().getDirectory() + File.separator + project.getArtifactId() + "-test.pdb";
	}

	if ( !( new File( testFileName ).exists() ) )
	{
	getLog().info( "NPANDAY-1100-001: No Unit Tests" );
	return;
	}

	Set<Artifact> artifacts;
	try
	{
	AndArtifactFilter filter = new AndArtifactFilter();
	filter.add(new ScopeArtifactFilter("test"));

	if (!resolvePdbs){
	filter.add(new InversionArtifactFilter(new DotnetSymbolsArtifactFilter()));
	}

	artifacts = dependencyResolution.require(
	project, LocalRepositoryUtil.create( localRepository ), filter
	);
	}
	catch ( ArtifactResolutionException e )
	{
	throw new MojoExecutionException(
	"NPANDAY-1100-009: dependency resolution for scope test failed!", e
	);
	}

	for ( Artifact artifact : artifacts )
	{
	if ( ArtifactTypeHelper.isDotnetAnyGac( artifact.getType() ) )
	{
	continue;
	}

	try
	{
	PathUtil.copyPlainArtifactFileToDirectory( artifact, new File( testAssemblyPath ) );
	}
	catch ( IOException e )
	{
	throw new MojoExecutionException( "NPANDAY-1100-002: Error on copying artifact " + artifact, e );
	}
	}

	try
	{
	if ( project.getArtifact() != null && project.getArtifact().getFile() != null
	&& project.getArtifact().getFile().exists() )
	{
	FileUtils.copyFileToDirectory( project.getArtifact().getFile(), new File( testAssemblyPath ) );
	}
	}
	catch ( IOException e )
	{
	throw new MojoExecutionException( "NPANDAY-1100-004: Unable to copy library to target directory: ", e );
	}

	try
	{
	FileUtils.copyFileToDirectory( new File( testFileName ), new File( testAssemblyPath ) );
	File pdbTestFile = new File( pdbTestFileName );
	if ( pdbTestFile.exists() )
	{
	FileUtils.copyFileToDirectory( pdbTestFile, new File( testAssemblyPath ) );
	}
	}
	catch ( IOException e )
	{
	throw new MojoExecutionException( "NPANDAY-1100-005: Unable to copy library to target directory: ", e );
	}

	FileUtils.mkdir( reportsDirectory );


	List<String> commands = getCommandsFor( );

	// pretty print nunit logs
	getLog().info( System.getProperty( "line.separator" ) );

	File executableHome = getExecutableHome();

	VendorRequirement vendorRequirement = new VendorRequirement( vendor, vendorVersion, executionFrameworkVersion );

	VendorInfo vendorInfo;
	try
	{
	vendorInfo = processor.process( vendorRequirement );
	}
	catch ( npanday.vendor.IllegalStateException e )
	{
	throw new MojoExecutionException(
	"NPANDAY-902-008: Illegal state of vendor info: Message = " + e.getMessage(), e);
	}
	catch ( PlatformUnsupportedException e )
	{
	throw new MojoExecutionException(
	"NPANDAY-902-009: Platform is unsupported: Message = " + e.getMessage(), e);
	}

	String profile = "NUNIT";
	if ( !vendorInfo.getVendor().equals( Vendor.MONO ) && forceX86 )
	{
	profile = "NUNIT-x86";
	}

	try
	{
	try
	{
	NetExecutable executable = netExecutableFactory.getExecutable(
	new ExecutableRequirement( vendorRequirement, profile ), commands,
	executableHome
	);

	executable.execute();
	}
	catch (PlatformUnsupportedException pue)
	{
	if (isNullOrEmpty(nunitCommand))
	{
	throw new MojoExecutionException( "NPANDAY-1100-008: Unsupported Platform.", pue );
	}

	// TODO: This should rather be done through a configurable local executable-plugins.xml; then remove nunitcommand
	getLog().debug( "NPANDAY-1100-008: Platform unsupported, is your npanday-settings.xml configured correctly?", pue );
	CommandExecutor commandExecutor = CommandExecutor.Factory.createDefaultCommmandExecutor(null);
	commandExecutor.setLogger( new org.codehaus.plexus.logging.AbstractLogger( 0, "nunit-logger" )
	{
	Log log = getLog();

	public void debug( String message, Throwable throwable )
	{
	log.debug( message, throwable );
	}

	public void error( String message, Throwable throwable )
	{
	log.error( message, throwable );
	}

	public void fatalError( String message, Throwable throwable )
	{
	log.error( message, throwable );
	}

	public Logger getChildLogger( String message )
	{
	return null;
	}

	public void info( String message, Throwable throwable )
	{
	log.info( message, throwable );
	}

	public void warn( String message, Throwable throwable )
	{
	log.warn( message, throwable );
	}
	} );

	String executablePath = (executableHome != null) ? new File(executableHome, nunitCommand).toString() : nunitCommand;
	commandExecutor.executeCommand( executablePath, commands );
	}
	}
	catch ( ExecutionException e )
	{
	String line = System.getProperty( "line.separator" );
	throw new MojoFailureException( "NPANDAY-1100-007: There are test failures." + line + line + e.getMessage(), e);
	}
	}
	}