[Springnet-commits] Spring.Net/tools/NAnt.NUnit2OutProc.Task/src/NAnt.NUnit2OutProc.Task ConsoleEvents.cs, NONE, 1.1 ITestDomain.cs, 1.1, 1.2 ITestDomainHost.cs, 1.1, 1.2 ITestDomainHostManager.cs, 1.1, 1.2 ITestDomainHostProcess.cs, 1.1, 1.2 NAnt.NUnit2OutProc.Task.csproj, 1.1, 1.2 NUnit2OutProcTask.cs, 1.1, 1.2 NUnit2TestDomain.cs, 1.1, 1.2 RemoteTestDomain.cs, 1.1, 1.2 RemotingUtil.cs, 1.1, 1.2 TestDomainHostManager.cs, 1.1, 1.2 TestDomainHostProcess.cs, 1.1, 1.2 TestDomainHostRegistration.cs, 1.1, 1.2

[Erich E. <oak...@us...>]

Update of /cvsroot/springnet/Spring.Net/tools/NAnt.NUnit2OutProc.Task/src/NAnt.NUnit2OutProc.Task
In directory sc8-pr-cvs8.sourceforge.net:/tmp/cvs-serv32244

Modified Files:
	ITestDomain.cs ITestDomainHost.cs ITestDomainHostManager.cs 
	ITestDomainHostProcess.cs NAnt.NUnit2OutProc.Task.csproj 
	NUnit2OutProcTask.cs NUnit2TestDomain.cs RemoteTestDomain.cs 
	RemotingUtil.cs TestDomainHostManager.cs 
	TestDomainHostProcess.cs TestDomainHostRegistration.cs 
Added Files:
	ConsoleEvents.cs 
Log Message:
graceful process shutdown on Control-C

Index: ITestDomain.cs
===================================================================
RCS file: /cvsroot/springnet/Spring.Net/tools/NAnt.NUnit2OutProc.Task/src/NAnt.NUnit2OutProc.Task/ITestDomain.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** ITestDomain.cs	19 Jan 2007 20:55:24 -0000	1.1
--- ITestDomain.cs	28 Jan 2007 16:39:36 -0000	1.2
***************
*** 4,15 ****
  namespace NAnt.NUnit2OutProc
  {
! 	/// <summary>
! 	/// Summary description for ITestDomain.
! 	/// </summary>
! 	public interface ITestDomain
! 	{
! 		void Unload();
  
! 		ObjectHandle CreateInstance(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingFlags, object[] args);
! 	}
  }
\ No newline at end of file
--- 4,16 ----
  namespace NAnt.NUnit2OutProc
  {
!   /// <summary>
!   /// Summary description for ITestDomain.
!   /// </summary>
!   public interface ITestDomain
!   {
!     void Unload();
  
!     ObjectHandle CreateInstance(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingFlags,
!                                 object[] args);
!   }
  }
\ No newline at end of file

Index: NUnit2OutProcTask.cs
===================================================================
RCS file: /cvsroot/springnet/Spring.Net/tools/NAnt.NUnit2OutProc.Task/src/NAnt.NUnit2OutProc.Task/NUnit2OutProcTask.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** NUnit2OutProcTask.cs	19 Jan 2007 20:55:24 -0000	1.1
--- NUnit2OutProcTask.cs	28 Jan 2007 16:39:37 -0000	1.2
***************
*** 38,491 ****
  namespace NAnt.NUnit2OutProc
  {
! 	/// <summary>
! 	/// Runs tests using the NUnit V2.2 framework.
! 	/// </summary>
! 	/// <remarks>
! 	///   <para>
! 	///   The <see cref="HaltOnFailure" /> attribute is only useful when more 
! 	///   than one test suite is used, and you want to continue running other 
! 	///   test suites although a test failed.
! 	///   </para>
! 	///   <para>
! 	///   Set <see cref="Task.FailOnError" /> to <see langword="false" /> to 
! 	///   ignore any errors and continue the build.
! 	///   </para>
! 	///   <para>
! 	///   In order to run a test assembly built with NUnit 2.0 or 2.1 using 
! 	///   <see cref="NUnit2OutProcTask" />, you must add the following node to your
! 	///   test config file :
! 	///   </para>
! 	///   <code>
! 	///     <![CDATA[
! 	/// <configuration>
! 	///     ...
! 	///     <runtime>
! 	///         <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
! 	///             <dependentAssembly>
! 	///                 <assemblyIdentity name="nunit.framework" publicKeyToken="96d09a1eb7f44a77" culture="Neutral" /> 
! 	///                 <bindingRedirect oldVersion="2.0.6.0" newVersion="2.2.8.0" /> 
! 	///                 <bindingRedirect oldVersion="2.1.4.0" newVersion="2.2.8.0" /> 
! 	///             </dependentAssembly>
! 	///         </assemblyBinding>
! 	///     </runtime>
! 	///     ...
! 	/// </configuration>
! 	///     ]]>
! 	///   </code>
! 	///   <para>
! 	///   See the <see href="http://nunit.sf.net">NUnit home page</see> for more 
! 	///   information.
! 	///   </para>
! 	/// </remarks>
! 	/// <example>
! 	///   <para>
! 	///   Run tests in the <c>MyProject.Tests.dll</c> assembly.
! 	///   </para>
! 	///   <code>
! 	///     <![CDATA[
! 	/// <nunit2outproc>
! 	///     <formatter type="Plain" />
! 	///     <test assemblyname="MyProject.Tests.dll" appconfig="MyProject.Tests.dll.config" />
! 	/// </nunit2outproc>
! 	///     ]]>
! 	///   </code>
! 	/// </example>
! 	/// <example>
! 	///   <para>
! 	///   Only run tests that are not known to fail in files listed in the <c>tests.txt</c>
! 	///   file.
! 	///   </para>
! 	///   <code>
! 	///     <![CDATA[
! 	/// <nunit2outproc>
! 	///     <formatter type="Xml" usefile="true" extension=".xml" outputdir="${build.dir}/results" />
! 	///     <test>
! 	///         <assemblies>
! 	///             <includesfile name="tests.txt" />
! 	///         </assemblies>
! 	///         <categories>
! 	///             <exclude name="NotWorking" />
! 	///         </categories>
! 	///     </test>
! 	/// </nunit2outproc>
! 	///     ]]>
! 	///   </code>
! 	/// </example>
! 	[TaskName("nunit2outproc")]
! 	public class NUnit2OutProcTask : Task
! 	{
! 		#region Private Instance Fields
  
! 		private bool _haltOnFailure = false;
! 		private NUnit2TestCollection _tests = new NUnit2TestCollection();
! 		private FormatterElementCollection _formatterElements = new FormatterElementCollection();
  
! 		#endregion Private Instance Fields
  
! 		#region Public Instance Properties
  
! 		/// <summary>
! 		/// Stop the test run if a test fails. The default is <see langword="false" />.
! 		/// </summary>
! 		[TaskAttribute("haltonfailure")]
! 		[BooleanValidator()]
! 		public bool HaltOnFailure
! 		{
! 			get { return _haltOnFailure; }
! 			set { _haltOnFailure = value; }
! 		}
  
! 		/// <summary>
! 		/// Tests to run.
! 		/// </summary>
! 		[BuildElementArray("test")]
! 		public NUnit2TestCollection Tests
! 		{
! 			get { return _tests; }
! 		}
  
! 		/// <summary>
! 		/// Formatters to output results of unit tests.
! 		/// </summary>
! 		[BuildElementArray("formatter")]
! 		public FormatterElementCollection FormatterElements
! 		{
! 			get { return _formatterElements; }
! 		}
  
! 		#endregion Public Instance Properties
  
! 		#region Override implementation of Task
  
! 		/// <summary>
! 		/// Runs the tests and sets up the formatters.
! 		/// </summary>
! 		protected override void ExecuteTask()
! 		{
! 			if (FormatterElements.Count == 0)
! 			{
! 				FormatterElement defaultFormatter = new FormatterElement();
! 				defaultFormatter.Project = Project;
! 				defaultFormatter.NamespaceManager = NamespaceManager;
! 				defaultFormatter.Type = FormatterType.Plain;
! 				defaultFormatter.UseFile = false;
! 				FormatterElements.Add(defaultFormatter);
  
! 				Log(Level.Warning, "No <formatter .../> element was specified." +
! 				                   " A plain-text formatter was added to prevent losing output of the" +
! 				                   " test results.");
  
! 				Log(Level.Warning, "Add a <formatter .../> element to the" +
! 				                   " <nunit2> task to prevent this warning from being output and" +
! 				                   " to ensure forward compatibility with future revisions of NAnt.");
! 			}
  
! 			LogWriter logWriter = new LogWriter(this, Level.Info, CultureInfo.InvariantCulture);
! 			EventListener listener = new EventCollector(logWriter, logWriter);
  
! 			foreach (NUnit2Test testElement in Tests)
! 			{
! 				IFilter categoryFilter = null;
  
! 				// include or exclude specific categories
! 				string categories = testElement.Categories.Includes.ToString();
! 				if (!StringUtils.IsNullOrEmpty(categories))
! 				{
! 					categoryFilter = new CategoryFilter(categories.Split(','), false);
! 				}
! 				else
! 				{
! 					categories = testElement.Categories.Excludes.ToString();
! 					if (!StringUtils.IsNullOrEmpty(categories))
! 					{
! 						categoryFilter = new CategoryFilter(categories.Split(','), true);
! 					}
! 				}
  
! 				foreach (string testAssembly in testElement.TestAssemblies)
! 				{
! 					NUnit2TestDomain domain = new NUnit2TestDomain(this.Project.TargetFramework);
  
! 					try
! 					{
! 						TestRunner runner = domain.CreateRunner(new FileInfo(testAssembly), testElement.AppConfigFile);
  
! 						Test test = null;
! 						if (testElement.TestName != null)
! 						{
! 							test = runner.Load(testAssembly, testElement.TestName);
! 						}
! 						else
! 						{
! 							test = runner.Load(testAssembly);
! 						}
  
! 						if (test == null)
! 						{
! 							Log(Level.Warning, "Assembly \"{0}\" contains no tests.",
! 							    testAssembly);
! 							continue;
! 						}
  
! 						// set category filter
! 						if (categoryFilter != null)
! 						{
! 							runner.Filter = categoryFilter;
! 						}
  
! 						// run test
! 						TestResult result = runner.Run(listener);
  
! 						// flush test output to log
! 						logWriter.Flush();
  
! 						// format test results using specified formatters
! 						FormatResult(testElement, result);
  
! 						if (result.IsFailure && (testElement.HaltOnFailure || HaltOnFailure))
! 						{
! 							throw new BuildException("Tests Failed.", Location);
! 						}
! 					}
! 					catch (BuildException)
! 					{
!                         // ensure temporary host processes are shutdown
! 						TestDomainHostManager.ShutdownHosts();
!                         // re-throw build exceptions
!                         throw;
! 					}
! 					catch (Exception ex)
! 					{
! 						if (!FailOnError)
! 						{
! 							// just log error and continue with next test
! 							Log(Level.Error, LogPrefix + "NUnit Error: " + ex.ToString());
! 							continue;
! 						}
  
! 						Log(Level.Error, LogPrefix + "NUnit Error: " + ex);
!                         // ensure temporary host processes are shutdown
!                         TestDomainHostManager.ShutdownHosts();
  
! 						Version nunitVersion = typeof (TestResult).Assembly.GetName().Version;
  
! 						throw new BuildException(string.Format(CultureInfo.InvariantCulture,
! 						                                       "Failure executing test(s). If you assembly is not built using"
! 						                                       + " NUnit version {0}, then ensure you have redirected assembly"
! 						                                       + " bindings. Consult the documentation of the <nunit2> task"
! 						                                       + " for more information.", nunitVersion), Location, ex);
! 					}
! 					finally
! 					{
! 						domain.Unload();
  
! 						// flush test output to log
! 						logWriter.Flush();
! 					}
! 				}
! 			}
! 		}
  
! 		#endregion Override implementation of Task
  
! 		#region Private Instance Methods
  
! 		private void FormatResult(NUnit2Test testElement, TestResult result)
! 		{
! 			// temp file for storing test results
! 			string xmlResultFile = Path.GetTempFileName();
  
! 			// permanent file for storing test results
! 			string outputFile = null;
  
! 			try
! 			{
! 				XmlResultVisitor resultVisitor = new XmlResultVisitor(xmlResultFile, result);
! 				result.Accept(resultVisitor);
! 				resultVisitor.Write();
  
! 				foreach (FormatterElement formatter in FormatterElements)
! 				{
! 					if (formatter.Type == FormatterType.Xml)
! 					{
! 						if (formatter.UseFile)
! 						{
! 							// determine file name for output file
! 							outputFile = result.Name + "-results" + formatter.Extension;
  
! 							if (formatter.OutputDirectory != null)
! 							{
! 								// ensure output directory exists
! 								if (!formatter.OutputDirectory.Exists)
! 								{
! 									formatter.OutputDirectory.Create();
! 								}
  
! 								// combine output directory and result filename
! 								outputFile = Path.Combine(formatter.OutputDirectory.FullName,
! 								                          Path.GetFileName(outputFile));
! 							}
  
! 							// copy the temp result file to permanent location
! 							File.Copy(xmlResultFile, outputFile, true);
! 						}
! 						else
! 						{
! 							using (StreamReader reader = new StreamReader(xmlResultFile))
! 							{
! 								// strip off the xml header
! 								reader.ReadLine();
! 								StringBuilder builder = new StringBuilder();
! 								while (reader.Peek() > -1)
! 								{
! 									builder.Append(reader.ReadLine().Trim()).Append(
! 										Environment.NewLine);
! 								}
! 								Log(Level.Info, builder.ToString());
! 							}
! 						}
! 					}
! 					else if (formatter.Type == FormatterType.Plain)
! 					{
! 						TextWriter writer;
! 						if (formatter.UseFile)
! 						{
! 							// determine file name for output file
! 							outputFile = result.Name + "-results" + formatter.Extension;
  
! 							if (formatter.OutputDirectory != null)
! 							{
! 								// ensure output directory exists
! 								if (!formatter.OutputDirectory.Exists)
! 								{
! 									formatter.OutputDirectory.Create();
! 								}
  
! 								// combine output directory and result filename
! 								outputFile = Path.Combine(formatter.OutputDirectory.FullName,
! 								                          Path.GetFileName(outputFile));
! 							}
  
! 							writer = new StreamWriter(outputFile);
! 						}
! 						else
! 						{
! 							writer = new LogWriter(this, Level.Info, CultureInfo.InvariantCulture);
! 						}
! 						CreateSummaryDocument(xmlResultFile, writer, testElement);
! 						writer.Close();
! 					}
! 				}
! 			}
! 			catch (Exception ex)
! 			{
! 				throw new BuildException("Test results could not be"
! 				                         + " formatted.", Location, ex);
! 			}
! 			finally
! 			{
! 				// make sure temp file with test results is removed
! 				File.Delete(xmlResultFile);
! 			}
! 		}
  
! 		private void CreateSummaryDocument(string resultFile, TextWriter writer, NUnit2Test test)
! 		{
! 			XPathDocument originalXPathDocument = new XPathDocument(resultFile);
! 			XslTransform summaryXslTransform = new XslTransform();
! 			XmlTextReader transformReader = GetTransformReader(test);
! 			summaryXslTransform.Load(transformReader);
! 			summaryXslTransform.Transform(originalXPathDocument, null, writer);
! 		}
  
! 		private XmlTextReader GetTransformReader(NUnit2Test test)
! 		{
! 			XmlTextReader transformReader;
! 			if (test.XsltFile == null)
! 			{
! 				Assembly assembly = Assembly.GetAssembly(typeof (XmlResultVisitor));
! 				ResourceManager resourceManager = new ResourceManager("NUnit.Util.Transform", assembly);
! 				string xmlData = (string) resourceManager.GetObject("Summary.xslt", CultureInfo.InvariantCulture);
! 				transformReader = new XmlTextReader(new StringReader(xmlData));
! 			}
! 			else
! 			{
! 				if (!test.XsltFile.Exists)
! 				{
! 					throw new BuildException(string.Format(CultureInfo.InvariantCulture,
! 					                                       "Transform file '{0}' does not exist.", test.XsltFile.FullName),
! 					                         Location);
! 				}
! 				transformReader = new XmlTextReader(test.XsltFile.FullName);
! 			}
  
! 			return transformReader;
! 		}
  
! 		#endregion Private Instance Methods
  
! 		private class EventCollector : LongLivingMarshalByRefObject, EventListener
! 		{
! 			private TextWriter outWriter;
! 			private TextWriter errorWriter;
! 			private string currentTestName;
  
! 			public EventCollector(TextWriter outWriter, TextWriter errorWriter)
! 			{
! 				this.outWriter = outWriter;
! 				this.errorWriter = errorWriter;
! 				this.currentTestName = string.Empty;
! 			}
  
! 			public void RunStarted(Test[] tests)
! 			{
! 			}
  
! 			public void RunFinished(TestResult[] results)
! 			{
! 			}
  
! 			public void RunFinished(Exception exception)
! 			{
! 			}
  
! 			public void TestFinished(TestCaseResult testResult)
! 			{
! 				currentTestName = string.Empty;
! 			}
  
! 			public void TestStarted(TestCase testCase)
! 			{
! 				currentTestName = testCase.FullName;
! 			}
  
! 			public void SuiteStarted(TestSuite suite)
! 			{
! 			}
  
! 			public void SuiteFinished(TestSuiteResult suiteResult)
! 			{
! 			}
  
! 			public void UnhandledException(Exception exception)
! 			{
! 				string msg = string.Format("##### Unhandled Exception while running {0}", currentTestName);
! 				errorWriter.WriteLine(msg);
! 				errorWriter.WriteLine(exception.ToString());
! 			}
  
! 			public void TestOutput(TestOutput output)
! 			{
! 				switch (output.Type)
! 				{
! 					case TestOutputType.Out:
! 						outWriter.Write(output.Text);
! 						break;
! 					case TestOutputType.Error:
! 						errorWriter.Write(output.Text);
! 						break;
! 				}
! 			}
! 		}
! 	}
  }
\ No newline at end of file
--- 38,491 ----
  namespace NAnt.NUnit2OutProc
  {
!   /// <summary>
!   /// Runs tests using the NUnit V2.2 framework.
!   /// </summary>
!   /// <remarks>
!   ///   <para>
!   ///   The <see cref="HaltOnFailure" /> attribute is only useful when more 
!   ///   than one test suite is used, and you want to continue running other 
!   ///   test suites although a test failed.
!   ///   </para>
!   ///   <para>
!   ///   Set <see cref="Task.FailOnError" /> to <see langword="false" /> to 
!   ///   ignore any errors and continue the build.
!   ///   </para>
!   ///   <para>
!   ///   In order to run a test assembly built with NUnit 2.0 or 2.1 using 
!   ///   <see cref="NUnit2OutProcTask" />, you must add the following node to your
!   ///   test config file :
!   ///   </para>
!   ///   <code>
!   ///     <![CDATA[
!   /// <configuration>
!   ///     ...
!   ///     <runtime>
!   ///         <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
!   ///             <dependentAssembly>
!   ///                 <assemblyIdentity name="nunit.framework" publicKeyToken="96d09a1eb7f44a77" culture="Neutral" /> 
!   ///                 <bindingRedirect oldVersion="2.0.6.0" newVersion="2.2.8.0" /> 
!   ///                 <bindingRedirect oldVersion="2.1.4.0" newVersion="2.2.8.0" /> 
!   ///             </dependentAssembly>
!   ///         </assemblyBinding>
!   ///     </runtime>
!   ///     ...
!   /// </configuration>
!   ///     ]]>
!   ///   </code>
!   ///   <para>
!   ///   See the <see href="http://nunit.sf.net">NUnit home page</see> for more 
!   ///   information.
!   ///   </para>
!   /// </remarks>
!   /// <example>
!   ///   <para>
!   ///   Run tests in the <c>MyProject.Tests.dll</c> assembly.
!   ///   </para>
!   ///   <code>
!   ///     <![CDATA[
!   /// <nunit2outproc>
!   ///     <formatter type="Plain" />
!   ///     <test assemblyname="MyProject.Tests.dll" appconfig="MyProject.Tests.dll.config" />
!   /// </nunit2outproc>
!   ///     ]]>
!   ///   </code>
!   /// </example>
!   /// <example>
!   ///   <para>
!   ///   Only run tests that are not known to fail in files listed in the <c>tests.txt</c>
!   ///   file.
!   ///   </para>
!   ///   <code>
!   ///     <![CDATA[
!   /// <nunit2outproc>
!   ///     <formatter type="Xml" usefile="true" extension=".xml" outputdir="${build.dir}/results" />
!   ///     <test>
!   ///         <assemblies>
!   ///             <includesfile name="tests.txt" />
!   ///         </assemblies>
!   ///         <categories>
!   ///             <exclude name="NotWorking" />
!   ///         </categories>
!   ///     </test>
!   /// </nunit2outproc>
!   ///     ]]>
!   ///   </code>
!   /// </example>
!   [TaskName("nunit2outproc")]
!   public class NUnit2OutProcTask : Task
!   {
!     #region Private Instance Fields
  
!     private bool _haltOnFailure = false;
!     private NUnit2TestCollection _tests = new NUnit2TestCollection();
!     private FormatterElementCollection _formatterElements = new FormatterElementCollection();
  
!     #endregion Private Instance Fields
  
!     #region Public Instance Properties
  
!     /// <summary>
!     /// Stop the test run if a test fails. The default is <see langword="false" />.
!     /// </summary>
!     [TaskAttribute("haltonfailure")]
!     [BooleanValidator()]
!     public bool HaltOnFailure
!     {
!       get { return _haltOnFailure; }
!       set { _haltOnFailure = value; }
!     }
  
!     /// <summary>
!     /// Tests to run.
!     /// </summary>
!     [BuildElementArray("test")]
!     public NUnit2TestCollection Tests
!     {
!       get { return _tests; }
!     }
  
!     /// <summary>
!     /// Formatters to output results of unit tests.
!     /// </summary>
!     [BuildElementArray("formatter")]
!     public FormatterElementCollection FormatterElements
!     {
!       get { return _formatterElements; }
!     }
  
!     #endregion Public Instance Properties
  
!     #region Override implementation of Task
  
!     /// <summary>
!     /// Runs the tests and sets up the formatters.
!     /// </summary>
!     protected override void ExecuteTask()
!     {
!       if (FormatterElements.Count == 0)
!       {
!         FormatterElement defaultFormatter = new FormatterElement();
!         defaultFormatter.Project = Project;
!         defaultFormatter.NamespaceManager = NamespaceManager;
!         defaultFormatter.Type = FormatterType.Plain;
!         defaultFormatter.UseFile = false;
!         FormatterElements.Add(defaultFormatter);
  
!         Log(Level.Warning, "No <formatter .../> element was specified." +
!                            " A plain-text formatter was added to prevent losing output of the" +
!                            " test results.");
  
!         Log(Level.Warning, "Add a <formatter .../> element to the" +
!                            " <nunit2> task to prevent this warning from being output and" +
!                            " to ensure forward compatibility with future revisions of NAnt.");
!       }
  
!       LogWriter logWriter = new LogWriter(this, Level.Info, CultureInfo.InvariantCulture);
!       EventListener listener = new EventCollector(logWriter, logWriter);
  
!       foreach (NUnit2Test testElement in Tests)
!       {
!         IFilter categoryFilter = null;
  
!         // include or exclude specific categories
!         string categories = testElement.Categories.Includes.ToString();
!         if (!StringUtils.IsNullOrEmpty(categories))
!         {
!           categoryFilter = new CategoryFilter(categories.Split(','), false);
!         }
!         else
!         {
!           categories = testElement.Categories.Excludes.ToString();
!           if (!StringUtils.IsNullOrEmpty(categories))
!           {
!             categoryFilter = new CategoryFilter(categories.Split(','), true);
!           }
!         }
  
!         foreach (string testAssembly in testElement.TestAssemblies)
!         {
!           NUnit2TestDomain domain = new NUnit2TestDomain(this.Project.TargetFramework);
  
!           try
!           {
!             TestRunner runner = domain.CreateRunner(new FileInfo(testAssembly), testElement.AppConfigFile);
  
!             Test test = null;
!             if (testElement.TestName != null)
!             {
!               test = runner.Load(testAssembly, testElement.TestName);
!             }
!             else
!             {
!               test = runner.Load(testAssembly);
!             }
  
!             if (test == null)
!             {
!               Log(Level.Warning, "Assembly \"{0}\" contains no tests.",
!                   testAssembly);
!               continue;
!             }
  
!             // set category filter
!             if (categoryFilter != null)
!             {
!               runner.Filter = categoryFilter;
!             }
  
!             // run test
!             TestResult result = runner.Run(listener);
  
!             // flush test output to log
!             logWriter.Flush();
  
!             // format test results using specified formatters
!             FormatResult(testElement, result);
  
!             if (result.IsFailure && (testElement.HaltOnFailure || HaltOnFailure))
!             {
!               throw new BuildException("Tests Failed.", Location);
!             }
!           }
!           catch (BuildException)
!           {
!             // ensure temporary host processes are shutdown
!             //TestDomainHostManager.ShutdownHosts();
!             // re-throw build exceptions
!             throw;
!           }
!           catch (Exception ex)
!           {
!             if (!FailOnError)
!             {
!               // just log error and continue with next test
!               Log(Level.Error, LogPrefix + "NUnit Error: " + ex.ToString());
!               continue;
!             }
  
!             Log(Level.Error, LogPrefix + "NUnit Error: " + ex);
!             // ensure temporary host processes are shutdown
!             //TestDomainHostManager.ShutdownHosts();
  
!             Version nunitVersion = typeof(TestResult).Assembly.GetName().Version;
  
!             throw new BuildException(string.Format(CultureInfo.InvariantCulture,
!                                                    "Failure executing test(s). If you assembly is not built using"
!                                                    + " NUnit version {0}, then ensure you have redirected assembly"
!                                                    + " bindings. Consult the documentation of the <nunit2> task"
!                                                    + " for more information.", nunitVersion), Location, ex);
!           }
!           finally
!           {
!             domain.Unload();
  
!             // flush test output to log
!             logWriter.Flush();
!           }
!         }
!       }
!     }
  
!     #endregion Override implementation of Task
  
!     #region Private Instance Methods
  
!     private void FormatResult(NUnit2Test testElement, TestResult result)
!     {
!       // temp file for storing test results
!       string xmlResultFile = Path.GetTempFileName();
  
!       // permanent file for storing test results
!       string outputFile = null;
  
!       try
!       {
!         XmlResultVisitor resultVisitor = new XmlResultVisitor(xmlResultFile, result);
!         result.Accept(resultVisitor);
!         resultVisitor.Write();
  
!         foreach (FormatterElement formatter in FormatterElements)
!         {
!           if (formatter.Type == FormatterType.Xml)
!           {
!             if (formatter.UseFile)
!             {
!               // determine file name for output file
!               outputFile = result.Name + "-results" + formatter.Extension;
  
!               if (formatter.OutputDirectory != null)
!               {
!                 // ensure output directory exists
!                 if (!formatter.OutputDirectory.Exists)
!                 {
!                   formatter.OutputDirectory.Create();
!                 }
  
!                 // combine output directory and result filename
!                 outputFile = Path.Combine(formatter.OutputDirectory.FullName,
!                                           Path.GetFileName(outputFile));
!               }
  
!               // copy the temp result file to permanent location
!               File.Copy(xmlResultFile, outputFile, true);
!             }
!             else
!             {
!               using (StreamReader reader = new StreamReader(xmlResultFile))
!               {
!                 // strip off the xml header
!                 reader.ReadLine();
!                 StringBuilder builder = new StringBuilder();
!                 while (reader.Peek() > -1)
!                 {
!                   builder.Append(reader.ReadLine().Trim()).Append(
!                     Environment.NewLine);
!                 }
!                 Log(Level.Info, builder.ToString());
!               }
!             }
!           }
!           else if (formatter.Type == FormatterType.Plain)
!           {
!             TextWriter writer;
!             if (formatter.UseFile)
!             {
!               // determine file name for output file
!               outputFile = result.Name + "-results" + formatter.Extension;
  
!               if (formatter.OutputDirectory != null)
!               {
!                 // ensure output directory exists
!                 if (!formatter.OutputDirectory.Exists)
!                 {
!                   formatter.OutputDirectory.Create();
!                 }
  
!                 // combine output directory and result filename
!                 outputFile = Path.Combine(formatter.OutputDirectory.FullName,
!                                           Path.GetFileName(outputFile));
!               }
  
!               writer = new StreamWriter(outputFile);
!             }
!             else
!             {
!               writer = new LogWriter(this, Level.Info, CultureInfo.InvariantCulture);
!             }
!             CreateSummaryDocument(xmlResultFile, writer, testElement);
!             writer.Close();
!           }
!         }
!       }
!       catch (Exception ex)
!       {
!         throw new BuildException("Test results could not be"
!                                  + " formatted.", Location, ex);
!       }
!       finally
!       {
!         // make sure temp file with test results is removed
!         File.Delete(xmlResultFile);
!       }
!     }
  
!     private void CreateSummaryDocument(string resultFile, TextWriter writer, NUnit2Test test)
!     {
!       XPathDocument originalXPathDocument = new XPathDocument(resultFile);
!       XslTransform summaryXslTransform = new XslTransform();
!       XmlTextReader transformReader = GetTransformReader(test);
!       summaryXslTransform.Load(transformReader);
!       summaryXslTransform.Transform(originalXPathDocument, null, writer);
!     }
  
!     private XmlTextReader GetTransformReader(NUnit2Test test)
!     {
!       XmlTextReader transformReader;
!       if (test.XsltFile == null)
!       {
!         Assembly assembly = Assembly.GetAssembly(typeof(XmlResultVisitor));
!         ResourceManager resourceManager = new ResourceManager("NUnit.Util.Transform", assembly);
!         string xmlData = (string) resourceManager.GetObject("Summary.xslt", CultureInfo.InvariantCulture);
!         transformReader = new XmlTextReader(new StringReader(xmlData));
!       }
!       else
!       {
!         if (!test.XsltFile.Exists)
!         {
!           throw new BuildException(string.Format(CultureInfo.InvariantCulture,
!                                                  "Transform file '{0}' does not exist.", test.XsltFile.FullName),
!                                    Location);
!         }
!         transformReader = new XmlTextReader(test.XsltFile.FullName);
!       }
  
!       return transformReader;
!     }
  
!     #endregion Private Instance Methods
  
!     private class EventCollector : LongLivingMarshalByRefObject, EventListener
!     {
!       private TextWriter outWriter;
!       private TextWriter errorWriter;
!       private string currentTestName;
  
!       public EventCollector(TextWriter outWriter, TextWriter errorWriter)
!       {
!         this.outWriter = outWriter;
!         this.errorWriter = errorWriter;
!         this.currentTestName = string.Empty;
!       }
  
!       public void RunStarted(Test[] tests)
!       {
!       }
  
!       public void RunFinished(TestResult[] results)
!       {
!       }
  
!       public void RunFinished(Exception exception)
!       {
!       }
  
!       public void TestFinished(TestCaseResult testResult)
!       {
!         currentTestName = string.Empty;
!       }
  
!       public void TestStarted(TestCase testCase)
!       {
!         currentTestName = testCase.FullName;
!       }
  
!       public void SuiteStarted(TestSuite suite)
!       {
!       }
  
!       public void SuiteFinished(TestSuiteResult suiteResult)
!       {
!       }
  
!       public void UnhandledException(Exception exception)
!       {
!         string msg = string.Format("##### Unhandled Exception while running {0}", currentTestName);
!         errorWriter.WriteLine(msg);
!         errorWriter.WriteLine(exception.ToString());
!       }
  
!       public void TestOutput(TestOutput output)
!       {
!         switch (output.Type)
!         {
!           case TestOutputType.Out:
!             outWriter.Write(output.Text);
!             break;
!           case TestOutputType.Error:
!             errorWriter.Write(output.Text);
!             break;
!         }
!       }
!     }
!   }
  }
\ No newline at end of file

Index: ITestDomainHost.cs
===================================================================
RCS file: /cvsroot/springnet/Spring.Net/tools/NAnt.NUnit2OutProc.Task/src/NAnt.NUnit2OutProc.Task/ITestDomainHost.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** ITestDomainHost.cs	19 Jan 2007 20:55:24 -0000	1.1
--- ITestDomainHost.cs	28 Jan 2007 16:39:36 -0000	1.2
***************
*** 4,11 ****
  namespace NAnt.NUnit2OutProc
  {
! 	public interface ITestDomainHost
! 	{
! 		Version CLRVersion { get; }
! 		ITestDomain CreateTestDomain(DirectoryInfo basedir, FileInfo assemblyFile, FileInfo configFile, string[] probePaths);
! 	}
  }
\ No newline at end of file
--- 4,11 ----
  namespace NAnt.NUnit2OutProc
  {
!   public interface ITestDomainHost
!   {
!     Version CLRVersion { get; }
!     ITestDomain CreateTestDomain(DirectoryInfo basedir, FileInfo assemblyFile, FileInfo configFile, string[] probePaths);
!   }
  }
\ No newline at end of file

Index: NUnit2TestDomain.cs
===================================================================
RCS file: /cvsroot/springnet/Spring.Net/tools/NAnt.NUnit2OutProc.Task/src/NAnt.NUnit2OutProc.Task/NUnit2TestDomain.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** NUnit2TestDomain.cs	19 Jan 2007 20:55:24 -0000	1.1
--- NUnit2TestDomain.cs	28 Jan 2007 16:39:37 -0000	1.2
***************
*** 19,24 ****
  
  using System;
- using System.Collections;
- using System.Diagnostics;
  using System.IO;
  using System.Reflection;
--- 19,22 ----
***************
*** 30,155 ****
  namespace NAnt.NUnit2OutProc
  {
! 	/// <summary>
! 	/// Custom TestDomain, similar to the one included with NUnit, in order 
! 	/// to workaround some limitations in it.
! 	/// </summary>
! 	internal class NUnit2TestDomain
! 	{
! 	    private ILog _log = LogManager.GetLogger(typeof(NUnit2TestDomain));
! 		private FrameworkInfo _frameworkInfo;
  
! 		#region Public Instance Constructors
  
! 		/// <summary>
! 		/// Initializes a new instance of the <see cref="NUnit2TestDomain" />
! 		/// class.
! 		/// </summary>
! 		public NUnit2TestDomain(FrameworkInfo frameworkInfo)
! 		{
! 			_frameworkInfo = frameworkInfo;
! 		}
  
! 		#endregion Public Instance Constructors
  
! 		#region Public Instance Methods
  
! 		/// <summary>
! 		/// Runs a single testcase.
! 		/// </summary>
! 		/// <param name="assemblyFile">The test assembly.</param>
! 		/// <param name="configFile">The application configuration file for the test domain.</param>
! 		/// <returns>
! 		/// The result of the test.
! 		/// </returns>
! 		public TestRunner CreateRunner(FileInfo assemblyFile, FileInfo configFile)
! 		{
! 		    try
! 		    {
!                 // assemble directories which can be probed for missing unresolved assembly references
!                 string baseDir = AppDomain.CurrentDomain.BaseDirectory;
!                 string libDir = Path.Combine(baseDir,"lib");
!                 string frameworkFamilyLibDir = Path.Combine(libDir,_frameworkInfo.Family);
!                 string frameworkVersionLibDir = Path.Combine(frameworkFamilyLibDir,_frameworkInfo.ClrVersion.ToString(2));
  
!                 string[] probePaths = {
! 			                      	frameworkVersionLibDir,
! 			                      	frameworkFamilyLibDir,
! 			                      	libDir,
! 			                      	baseDir
! 			                      };
  
!                 // create test domain
!                 _domain = CreateDomain(_frameworkInfo,assemblyFile.Directory,assemblyFile,
!                                        configFile,probePaths);
! 		    }
! 		    catch(Exception ex)
! 		    {
! 		        _log.Error("CreateRunner(): failed creating TestDomain", ex);
! 		        throw;
! 		    }
  
! 			// create testrunner
! 			TestRunner runner = CreateTestRunner(_domain);
!             _log.Debug("CreateRunner(): created TestRunner in TestDomain");
! 		    return runner;
!   		}
  
! 		public void Unload()
! 		{
! 			if (_domain != null)
! 			{
! 				try
! 				{
! 					_domain.Unload();
! 				}
! 				catch(Exception ex)
! 				{
!                     _log.Error("Unload(): error unloading TestDomain",ex);
! 					// ignore exceptions during unload, this matches the 
! 					// behaviour of the NUnit TestDomain
! 				}
! 				finally
! 				{
! 					_domain = null;
! 				}
!                 _log.Debug("Unload(): unloaded TestDomain");
!             }
! 		}
  
! 		#endregion Public Instance Methods
  
! 		#region Private Instance Methods
  
! 		private static ITestDomain CreateDomain(FrameworkInfo frameworkInfo, DirectoryInfo basedir, FileInfo assemblyFile, FileInfo configFile, string[] probePaths)
! 		{
! 			ITestDomainHost testHost = TestDomainHostManager.GetTestDomainHost(frameworkInfo);
! 			ITestDomain testDomain = testHost.CreateTestDomain(basedir, assemblyFile, configFile, probePaths);
! 			return testDomain;
! 		}
  
! 		private static RemoteTestRunner CreateTestRunner(ITestDomain domain)
! 		{
! 			Type rtrType = typeof (RemoteTestRunner);
! 			
! 			ObjectHandle oh = domain.CreateInstance(
! 				rtrType.Assembly.FullName,
! 				rtrType.FullName,
! 				false,
! 				BindingFlags.Public | BindingFlags.Instance,
! 				null
! 				);
  
!             object o = oh.Unwrap();
! 			
! 			return (RemoteTestRunner) o;
! 		}
  
! 		#endregion Private Instance Methods
  
! 		#region Private Instance Fields
  
! 		private ITestDomain _domain;
  
! 		#endregion Private Instance Fields
! 	}
  }
\ No newline at end of file
--- 28,154 ----
  namespace NAnt.NUnit2OutProc
  {
!   /// <summary>
!   /// Custom TestDomain, similar to the one included with NUnit, in order 
!   /// to workaround some limitations in it.
!   /// </summary>
!   internal class NUnit2TestDomain
!   {
!     private ILog _log = LogManager.GetLogger(typeof(NUnit2TestDomain));
!     private FrameworkInfo _frameworkInfo;
  
!     #region Public Instance Constructors
  
!     /// <summary>
!     /// Initializes a new instance of the <see cref="NUnit2TestDomain" />
!     /// class.
!     /// </summary>
!     public NUnit2TestDomain(FrameworkInfo frameworkInfo)
!     {
!       _frameworkInfo = frameworkInfo;
!     }
  
!     #endregion Public Instance Constructors
  
!     #region Public Instance Methods
  
!     /// <summary>
!     /// Runs a single testcase.
!     /// </summary>
!     /// <param name="assemblyFile">The test assembly.</param>
!     /// <param name="configFile">The application configuration file for the test domain.</param>
!     /// <returns>
!     /// The result of the test.
!     /// </returns>
!     public TestRunner CreateRunner(FileInfo assemblyFile, FileInfo configFile)
!     {
!       try
!       {
!         // assemble directories which can be probed for missing unresolved assembly references
!         string baseDir = AppDomain.CurrentDomain.BaseDirectory;
!         string libDir = Path.Combine(baseDir, "lib");
!         string frameworkFamilyLibDir = Path.Combine(libDir, _frameworkInfo.Family);
!         string frameworkVersionLibDir = Path.Combine(frameworkFamilyLibDir, _frameworkInfo.ClrVersion.ToString(2));
  
!         string[] probePaths = {
!                                 frameworkVersionLibDir,
!                                 frameworkFamilyLibDir,
!                                 libDir,
!                                 baseDir
!                               };
  
!         // create test domain
!         _domain = CreateDomain(_frameworkInfo, assemblyFile.Directory, assemblyFile,
!                                configFile, probePaths);
!       }
!       catch (Exception ex)
!       {
!         _log.Error("CreateRunner(): failed creating TestDomain", ex);
!         throw;
!       }
  
!       // create testrunner
!       TestRunner runner = CreateTestRunner(_domain);
!       _log.Debug("CreateRunner(): created TestRunner in TestDomain");
!       return runner;
!     }
  
!     public void Unload()
!     {
!       if (_domain != null)
!       {
!         try
!         {
!           _domain.Unload();
!         }
!         catch (Exception ex)
!         {
!           _log.Error("Unload(): error unloading TestDomain", ex);
!           // ignore exceptions during unload, this matches the 
!           // behaviour of the NUnit TestDomain
!         }
!         finally
!         {
!           _domain = null;
!         }
!         _log.Debug("Unload(): unloaded TestDomain");
!       }
!     }
  
!     #endregion Public Instance Methods
  
!     #region Private Instance Methods
  
!     private static ITestDomain CreateDomain(FrameworkInfo frameworkInfo, DirectoryInfo basedir, FileInfo assemblyFile,
!                                             FileInfo configFile, string[] probePaths)
!     {
!       ITestDomainHost testHost = TestDomainHostManager.GetTestDomainHost(frameworkInfo);
!       ITestDomain testDomain = testHost.CreateTestDomain(basedir, assemblyFile, configFile, probePaths);
!       return testDomain;
!     }
  
!     private static RemoteTestRunner CreateTestRunner(ITestDomain domain)
!     {
!       Type rtrType = typeof(RemoteTestRunner);
  
!       ObjectHandle oh = domain.CreateInstance(
!         rtrType.Assembly.FullName,
!         rtrType.FullName,
!         false,
!         BindingFlags.Public | BindingFlags.Instance,
!         null
!         );
  
!       object o = oh.Unwrap();
  
!       return (RemoteTestRunner) o;
!     }
  
!     #endregion Private Instance Methods
  
!     #region Private Instance Fields
! 
!     private ITestDomain _domain;
! 
!     #endregion Private Instance Fields
!   }
  }
\ No newline at end of file

Index: TestDomainHostRegistration.cs
===================================================================
RCS file: /cvsroot/springnet/Spring.Net/tools/NAnt.NUnit2OutProc.Task/src/NAnt.NUnit2OutProc.Task/TestDomainHostRegistration.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** TestDomainHostRegistration.cs	19 Jan 2007 20:55:24 -0000	1.1
--- TestDomainHostRegistration.cs	28 Jan 2007 16:39:37 -0000	1.2
***************
*** 6,107 ****
  namespace NAnt.NUnit2OutProc
  {
! 	public class TestDomainHostRegistration : IDisposable
! 	{
! 	    private ILog Trace;
  
! 		private Version _clrVersion;
! 		private Process _process;
! 		private FileInfo[] _fileDependencies;
! 		private ITestDomainHostProcess _hostProcess;
  
! 		public TestDomainHostRegistration(Version clrVersion, Process process, FileInfo[] fileDependencies)
! 		{
!             if(process == null) throw new ArgumentNullException("process");
  
! 			this._clrVersion = clrVersion;
! 			this._process = process;
! 			this._fileDependencies = fileDependencies;
  
!             Trace = LogManager.GetLogger(typeof(TestDomainHostRegistration) + "[" + _clrVersion + "]");
! 		}
  
! 		public void SetHostProcess(ITestDomainHostProcess hostProcess)
! 		{
! 			this._hostProcess = hostProcess;
! 		}
  
! 		public ITestDomainHostProcess HostProcess
! 		{
! 			get { return this._hostProcess; }
! 		}
  
! 		public Version ClrVersion
! 		{
! 			get { return this._clrVersion; }
! 		}
  
! 		public void Dispose()
! 		{
!             Trace.Debug("Dispose(): shutting down");
  
! 			if (this._hostProcess != null)
! 			{
! 				try
! 				{
! 					this._hostProcess.ShutDown();
! 				}
! 				catch (Exception ex)
! 				{
! 					Trace.Error("Dispose(): Error shutting down host process", ex);
! 				}
! 				finally
! 				{
! 					this._hostProcess = null;
! 				}
! 			}
  
! 			try
! 			{
! 				Trace.Debug("Dispose(): waiting for process exit");
! 			    if(this._process != null)
! 			    {
! 			        bool bOk = this._process.WaitForExit(1000);
! 			        if (!bOk)
! 			        {
! 			            Trace.Debug("Dispose(): killing process");
! 			            // kill the process
! 			            this._process.Kill();
! 			            this._process.WaitForExit(1000);
! 			        }
! 			    }
!                 else
! 			    {
! 			        Trace.Debug("Dispose(): Process is null - nothing to do");
! 			    }
! 			}
! 			catch (Exception ex)
! 			{
! 				Trace.Error("Dispose(): Error waiting for process exit", ex);
! 			}
! 			finally
! 			{
! 				this._process = null;
! 			}
  
! 			foreach (FileInfo fileDep in this._fileDependencies)
! 			{
! 				try
! 				{
! 					Trace.Debug("Dispose(): deleting tmp file '{0}'", fileDep.FullName);
! 					fileDep.Delete();
! 				}
! 				catch (Exception ex)
! 				{
! 					Trace.Error("Dispose(): Error deleting file '{0}': {1}", ex, fileDep.FullName);
! 				}
! 			}
  
!             Trace.Debug("Dispose(): shut down completed");
! 		}
! 	}
  }
\ No newline at end of file
--- 6,107 ----
  namespace NAnt.NUnit2OutProc
  {
!   public class TestDomainHostRegistration : IDisposable
!   {
!     private ILog Trace;
  
!     private Version _clrVersion;
!     private Process _process;
!     private FileInfo[] _fileDependencies;
!     private ITestDomainHostProcess _hostProcess;
  
!     public TestDomainHostRegistration(Version clrVersion, Process process, FileInfo[] fileDependencies)
!     {
!       if (process == null) throw new ArgumentNullException("process");
  
!       this._clrVersion = clrVersion;
!       this._process = process;
!       this._fileDependencies = fileDependencies;
  
!       Trace = LogManager.GetLogger(typeof(TestDomainHostRegistration) + "[" + _clrVersion + "]");
!     }
  
!     public void SetHostProcess(ITestDomainHostProcess hostProcess)
!     {
!       this._hostProcess = hostProcess;
!     }
  
!     public ITestDomainHostProcess HostProcess
!     {
!       get { return this._hostProcess; }
!     }
  
!     public Version ClrVersion
!     {
!       get { return this._clrVersion; }
!     }
  
!     public void Dispose()
!     {
!       Trace.Debug("Dispose(): shutting down");
  
!       if (this._hostProcess != null)
!       {
!         try
!         {
!           this._hostProcess.ShutDown();
!         }
!         catch (Exception ex)
!         {
!           Trace.Error("Dispose(): Error shutting down host process", ex);
!         }
!         finally
!         {
!           this._hostProcess = null;
!         }
!       }
  
!       try
!       {
!         Trace.Debug("Dispose(): waiting for process exit");
!         if (this._process != null)
!         {
!           bool bOk = this._process.WaitForExit(1000);
!           if (!bOk)
!           {
!             Trace.Debug("Dispose(): killing process");
!             // kill the process
!             this._process.Kill();
!             this._process.WaitForExit(1000);
!           }
!         }
!         else
!         {
!           Trace.Debug("Dispose(): Process is null - nothing to do");
!         }
!       }
!       catch (Exception ex)
!       {
!         Trace.Error("Dispose(): Error waiting for process exit", ex);
!       }
!       finally
!       {
!         this._process = null;
!       }
  
!       foreach (FileInfo fileDep in this._fileDependencies)
!       {
!         try
!         {
!           Trace.Debug("Dispose(): deleting tmp file '{0}'", fileDep.FullName);
!           fileDep.Delete();
!         }
!         catch (Exception ex)
!         {
!           Trace.Error("Dispose(): Error deleting file '{0}': {1}", ex, fileDep.FullName);
!         }
!       }
  
!       Trace.Debug("Dispose(): shut down completed");
!     }
!   }
  }
\ No newline at end of file

Index: ITestDomainHostProcess.cs
===================================================================
RCS file: /cvsroot/springnet/Spring.Net/tools/NAnt.NUnit2OutProc.Task/src/NAnt.NUnit2OutProc.Task/ITestDomainHostProcess.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** ITestDomainHostProcess.cs	19 Jan 2007 20:55:24 -0000	1.1
--- ITestDomainHostProcess.cs	28 Jan 2007 16:39:37 -0000	1.2
***************
*** 1,8 ****
  namespace NAnt.NUnit2OutProc
  {
! 	public interface ITestDomainHostProcess : ITestDomainHost
! 	{
! 		void RegistrationCommit();
! 		void ShutDown();
! 	}
  }
\ No newline at end of file
--- 1,8 ----
  namespace NAnt.NUnit2OutProc
  {
!   public interface ITestDomainHostProcess : ITestDomainHost
!   {
!     void RegistrationCommit();
!     void ShutDown();
!   }
  }
\ No newline at end of file

Index: NAnt.NUnit2OutProc.Task.csproj
===================================================================
RCS file: /cvsroot/springnet/Spring.Net/tools/NAnt.NUnit2OutProc.Task/src/NAnt.NUnit2OutProc.Task/NAnt.NUnit2OutProc.Task.csproj,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** NAnt.NUnit2OutProc.Task.csproj	19 Jan 2007 20:55:24 -0000	1.1
--- NAnt.NUnit2OutProc.Task.csproj	28 Jan 2007 16:39:37 -0000	1.2
***************
*** 101,104 ****
--- 101,105 ----
        <SubType>Code</SubType>
      </Compile>
+     <Compile Include="ConsoleEvents.cs" />
      <Compile Include="Logging\TraceLogger.cs" />
      <Compile Include="Logging\ILog.cs" />

Index: RemotingUtil.cs
===================================================================
RCS file: /cvsroot/springnet/Spring.Net/tools/NAnt.NUnit2OutProc.Task/src/NAnt.NUnit2OutProc.Task/RemotingUtil.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** RemotingUtil.cs	19 Jan 2007 20:55:24 -0000	1.1
--- RemotingUtil.cs	28 Jan 2007 16:39:37 -0000	1.2
***************
*** 8,58 ****
  namespace NAnt.NUnit2OutProc
  {
! 	/// <summary>
! 	/// Summary description for RemotingUtil.
! 	/// </summary>
! 	public class RemotingUtil
! 	{
! 	    private static ILog s_log = LogManager.GetLogger(typeof(RemotingUtil));
! 
! 		private RemotingUtil()
! 		{
! 		}
! 		
! 		public static void InitializeRemoting()
! 		{
! 			BinaryServerFormatterSinkProvider serverProv = new BinaryServerFormatterSinkProvider();
! 			serverProv.TypeFilterLevel = TypeFilterLevel.Full;
  
! 			BinaryClientFormatterSinkProvider clientProv = new BinaryClientFormatterSinkProvider();
  
! 			IChannel tcpChannel = null;
! 		    Exception lastEx = null;
! 			IDictionary props = new Hashtable();
! 			int cRetries = 4;
! 			while (cRetries > 0)
! 			{
! 				try
! 				{
! 					props["port"] = new Random(DateTime.Now.Millisecond).Next(10000, 60000);
! 					tcpChannel = new TcpChannel(props, clientProv, serverProv);
!                     s_log.Debug("InitializeRemoting(): found free tcp port {0}", props["port"]);
! 					cRetries = 0;
! 				    lastEx = null;
! 				}
! 				catch(Exception ex)
! 				{
! 				    lastEx = ex;
! 					cRetries--;
! 				}
! 			}
  
!             if (lastEx != null)
!             {
!                 s_log.Error("InitializeRemoting(): couldn't find free tcp port", lastEx);
!             }
  
!             ChannelServices.RegisterChannel(tcpChannel);
!             s_log.Debug("InitializeRemoting(): registered TCP-channel");
          }
! 	}
! }
--- 8,58 ----
  namespace NAnt.NUnit2OutProc
  {
!   /// <summary>
!   /// Summary description for RemotingUtil.
!   /// </summary>
!   public class RemotingUtil
!   {
!     private static ILog s_log = LogManager.GetLogger(typeof(RemotingUtil));
  
!     private RemotingUtil()
!     {
!     }
  
!     public static void InitializeRemoting()
!     {
!       BinaryServerFormatterSinkProvider serverProv = new BinaryServerFormatterSinkProvider();
!       serverProv.TypeFilterLevel = TypeFilterLevel.Full;
  
!       BinaryClientFormatterSinkProvider clientProv = new BinaryClientFormatterSinkProvider();
  
!       IChannel tcpChannel = null;
!       Exception lastEx = null;
!       IDictionary props = new Hashtable();
!       int cRetries = 4;
!       while (cRetries > 0)
!       {
!         try
!         {
!           props["port"] = new Random(DateTime.Now.Millisecond).Next(10000, 60000);
!           tcpChannel = new TcpChannel(props, clientProv, serverProv);
!           s_log.Debug("InitializeRemoting(): found free tcp port {0}", props["port"]);
!           cRetries = 0;
!           lastEx = null;
          }
!         catch (Exception ex)
!         {
!           lastEx = ex;
!           cRetries--;
!         }
!       }
! 
!       if (lastEx != null)
!       {
!         s_log.Error("InitializeRemoting(): couldn't find free tcp port", lastEx);
!       }
! 
!       ChannelServices.RegisterChannel(tcpChannel);
!       s_log.Debug("InitializeRemoting(): registered TCP-channel");
!     }
!   }
! }
\ No newline at end of file

Index: RemoteTestDomain.cs
===================================================================
RCS file: /cvsroot/springnet/Spring.Net/tools/NAnt.NUnit2OutProc.Task/src/NAnt.NUnit2OutProc.Task/RemoteTestDomain.cs,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** RemoteTestDomain.cs	19 Jan 2007 20:55:24 -0000	1.1
--- RemoteTestDomain.cs	28 Jan 2007 16:39:37 -0000	1.2
***************
*** 1,5 ****
  using System;
  using System.Collections;
- using System.Diagnostics;
  using System.Globalization;
  using System.IO;
--- 1,4 ----
***************
*** 10,253 ****
  namespace NAnt.NUnit2OutProc
  {
! 	/// <summary>
! 	/// A remoting wrapper for the actual TestDomain.
! 	/// </summary>
! 	public class RemoteTestDomain : MarshalByRefObject, ITestDomain
! 	{
! 	    private ILog _log = LogManager.GetLogger(typeof(RemoteTestDomain) + "[" + Environment.Version + "]");
!             
!         /// <summary>
!         /// holds the actual testdomain
!         /// </summary>
! 		private AppDomain _testDomain;
  
!         /// <summary>
!         /// Wrap a domain and install a <see cref="TestDomainSetup"/> instance.
!         /// </summary>
! 		public RemoteTestDomain(AppDomain testDomain, string[] probePaths)
! 		{
! 			_testDomain = testDomain;
  
!             // install TestDomainSetup instance
! 		    try
! 		    {
! 		        _testDomain.CreateInstanceFrom(Assembly.GetExecutingAssembly().CodeBase,
! 		                                       typeof(TestDomainSetup).FullName,
! 		                                       false,
! 		                                       BindingFlags.Public | BindingFlags.Instance,
! 		                                       null,
! 		                                       new object[] {probePaths},
! 		                                       CultureInfo.InvariantCulture,
! 		                                       null,
! 		                                       AppDomain.CurrentDomain.Evidence);
! 		    }
! 		    catch(Exception ex)
! 		    {
!                 _log.Error(".ctor(): Failed installing TestDomainSetup in TestDomain",ex);
! 		        throw;
! 		    }
  
!             _log.Debug(".ctor(): Created and installed TestDomainSetup in TestDomain");
! 		}
  
! 		public override object InitializeLifetimeService()
! 		{
! 			return null;
! 		}
  
! 		public void Unload()
! 		{
! 			try
! 			{
! 				AppDomain.Unload(_testDomain);
! 			}
! 			catch (CannotUnloadAppDomainException)
! 			{
! 				// ignore exceptions during unload, this matches the 
! 				// behaviour of the NUnit TestDomain
! 			}
! 			finally
! 			{
! 				_testDomain = null;
!                 _log.Debug("Unload(): unloaded TestDomain");
! 			}
! 		}
  
! 		public ObjectHandle CreateInstance(string assemblyName, string typeName, bool ignoreCase,
! 		                             BindingFlags bindingFlags, object[] args)
! 		{
! 		    try
! 		    {
! 		        ObjectHandle oh = _testDomain.CreateInstance(
! 		            assemblyName,
! 		            typeName,
! 		            ignoreCase,
! 		            bindingFlags,
! 		            null,
! 		            args,
! 		            CultureInfo.InvariantCulture,
! 		            null,
! 		            AppDomain.CurrentDomain.Evidence
! 		            );
  
!                 _log.Debug("CreateInstance(): created instance of type '{0},{1}'",assemblyName,typeName);
  
!                 return oh;
! 		    }
! 		    catch(Exception ex)
! 		    {
!                 _log.Error("CreateInstance(): failed to create instance of type '{0}, {1}'", ex, assemblyName, typeName);
! 		        throw;
!             }			
! 		}
  
!         #region Helper Class
  
!         /// <summary>
!         /// Helper class called when an assembly resolve event is raised.
!         /// </summary>
!         [Serializable()]
!         private class TestDomainSetup
!         {
!             private ILog log;
  
!             #region Public Instance Constructors
  
!             /// <summary> 
!             /// Initializes an instanse of the <see cref="TestDomainSetup" /> 
!             /// class.
!             /// </summary>
!             public TestDomainSetup(string[] probePaths)
!             {
!                 _assemblyCache = new Hashtable();
!                 _probePaths = probePaths;
  
!                 log = LogManager.GetLogger(this.GetType().FullName + "[" + Environment.Version + "]");
  
!                 // attach handlers for the current domain.
!                 AppDomain.CurrentDomain.AssemblyResolve +=
! 					new ResolveEventHandler(this.OnAssemblyResolve);
!                 AppDomain.CurrentDomain.AssemblyLoad +=
! 					new AssemblyLoadEventHandler(this.OnAssemblyLoad);
  
!                 RemotingUtil.InitializeRemoting();
  
!                 log.Debug(".ctor(): installed with paths " + string.Join(";",probePaths));
!             }
  
!             #endregion Public Instance Constructors
  
!             #region Public Instance Methods
  
!             /// <summary>
!             /// Called back when the CLR cannot resolve a given assembly.
!             /// </summary>
!             /// <param name="sender">The source of the event.</param>
!             /// <param name="args">A <see cref="ResolveEventArgs" /> that contains the event data.</param>
!             /// <returns>
!             /// The <c>nunit.framework</c> we know to be in NAnts bin directory, if 
!             /// that is the assembly that needs to be resolved; otherwise, 
!             /// <see langword="null" />.
!             /// </returns>
!             public Assembly OnAssemblyResolve(Object sender,ResolveEventArgs args)
              {
!                 log.Debug("OnAssemblyResolve(): resolving " + args.Name);
!                 bool isFullName = args.Name.IndexOf("Version=") != -1;
  
!                 // find assembly in cache
!                 if(isFullName)
!                 {
!                     if(_assemblyCache.Contains(args.Name))
!                     {
!                         // return assembly from cache
!                         return (Assembly)_assemblyCache[args.Name];
!                     }
!                 }
!                 else
                  {
!                     foreach(Assembly assembly in _assemblyCache.Values)
!                     {
!                         if(assembly.GetName(false).Name == args.Name)
!                         {
!                             // return assembly from cache
!                             return assembly;
!                         }
!                     }
                  }
! 
!                 // find assembly in probe paths
!                 foreach(string path in _probePaths)
                  {
!                     if(!Directory.Exists(path))
!                     {
!                         continue;
!                     }
! 
!                     string[] assemblies = Directory.GetFiles(path,"*.dll");
! 
!                     foreach(string assemblyFile in assemblies)
!                     {
!                         try
!                         {
!                             AssemblyName assemblyName = AssemblyName.GetAssemblyName(assemblyFile);
!                             if(isFullName)
!                             {
!                                 if(assemblyName.FullName == args.Name)
!                                 {
!                                     return Assembly.LoadFrom(assemblyFile);
!                                 }
!                             }
!                             else
!                             {
!                                 if(assemblyName.Name == args.Name)
!                                 {
!                                     return Assembly.LoadFrom(assemblyFile);
!                                 }
!                             }
!                         }
!                         catch
!                         {
!                         }
!                     }
                  }
! 
!                 // assembly reference could not be resolved
!                 log.Debug("OnAssemblyResolve(): failed resolving " + args.Name);
!                 return null;
              }
! 
!             /// <summary>
!             /// Occurs when an assembly is loaded. The loaded assembly is added 
!             /// to the assembly cache.
!             /// </summary>
!             /// <param name="sender">The source of the event.</param>
!             /...
 
[truncated message content]