nunit24/ConsoleRunner/nunit-console/ConsoleUi.cs

   1 // ****************************************************************
   2 // This is free software licensed under the NUnit license. You
   3 // may obtain a copy of the license as well as information regarding
   4 // copyright ownership at http://nunit.org/?p=license&r=2.4.
   5 // ****************************************************************
   6
   7 namespace NUnit.ConsoleRunner
   8 {
   9         using System;
  10         using System.IO;
  11         using System.Reflection;
  12         using System.Xml;
  13         using System.Resources;
  14         using System.Text;
  15         using NUnit.Core;
  16         using NUnit.Core.Filters;
  17         using NUnit.Util;
  18
  19         /// <summary>
  20         /// Summary description for ConsoleUi.
  21         /// </summary>
  22         public class ConsoleUi
  23         {
  24                 public static readonly int OK = 0;
  25                 public static readonly int INVALID_ARG = -1;
  26                 public static readonly int FILE_NOT_FOUND = -2;
  27                 public static readonly int FIXTURE_NOT_FOUND = -3;
  28                 public static readonly int TRANSFORM_ERROR = -4;
  29                 public static readonly int UNEXPECTED_ERROR = -100;
  30
  31                 public ConsoleUi()
  32                 {
  33                 }
  34
  35                 public int Execute( ConsoleOptions options )
  36                 {
  37                         XmlTextReader transformReader = GetTransformReader(options);
  38                         if(transformReader == null) return FILE_NOT_FOUND;
  39
  40                         TextWriter outWriter = Console.Out;
  41                         bool redirectOutput = options.output != null && options.output != string.Empty;
  42                         if ( redirectOutput )
  43                         {
  44                                 StreamWriter outStreamWriter = new StreamWriter( options.output );
  45                                 outStreamWriter.AutoFlush = true;
  46                                 outWriter = outStreamWriter;
  47                         }
  48
  49                         TextWriter errorWriter = Console.Error;
  50                         bool redirectError = options.err != null && options.err != string.Empty;
  51                         if ( redirectError )
  52                         {
  53                                 StreamWriter errorStreamWriter = new StreamWriter( options.err );
  54                                 errorStreamWriter.AutoFlush = true;
  55                                 errorWriter = errorStreamWriter;
  56                         }
  57
  58                         TestRunner testRunner = MakeRunnerFromCommandLine( options );
  59
  60                         try
  61                         {
  62                                 if (testRunner.Test == null)
  63                                 {
  64                                         testRunner.Unload();
  65                                         Console.Error.WriteLine("Unable to locate fixture {0}", options.fixture);
  66                                         return FIXTURE_NOT_FOUND;
  67                                 }
  68
  69                                 EventCollector collector = new EventCollector( options, outWriter, errorWriter );
  70
  71                                 TestFilter testFilter = TestFilter.Empty;
  72                                 if ( options.run != null && options.run != string.Empty )
  73                                 {
  74                                         Console.WriteLine( "Selected test: " + options.run );
  75                                         testFilter = new SimpleNameFilter( options.run );
  76                                 }
  77
  78                                 if ( options.include != null && options.include != string.Empty )
  79                                 {
  80                                         Console.WriteLine( "Included categories: " + options.include );
  81                                         TestFilter includeFilter = new CategoryExpression( options.include ).Filter;
  82                                         if ( testFilter.IsEmpty )
  83                                                 testFilter = includeFilter;
  84                                         else
  85                                                 testFilter = new AndFilter( testFilter, includeFilter );
  86                                 }
  87
  88                                 if ( options.exclude != null && options.exclude != string.Empty )
  89                                 {
  90                                         Console.WriteLine( "Excluded categories: " + options.exclude );
  91                                         TestFilter excludeFilter = new NotFilter( new CategoryExpression( options.exclude ).Filter );
  92                                         if ( testFilter.IsEmpty )
  93                                                 testFilter = excludeFilter;
  94                                         else if ( testFilter is AndFilter )
  95                                                 ((AndFilter)testFilter).Add( excludeFilter );
  96                                         else
  97                                                 testFilter = new AndFilter( testFilter, excludeFilter );
  98                                 }
  99
 100                                 TestResult result = null;
 101                                 string savedDirectory = Environment.CurrentDirectory;
 102                                 TextWriter savedOut = Console.Out;
 103                                 TextWriter savedError = Console.Error;
 104
 105                                 try
 106                                 {
 107                                         result = testRunner.Run( collector, testFilter );
 108                                 }
 109                                 finally
 110                                 {
 111                                         outWriter.Flush();
 112                                         errorWriter.Flush();
 113
 114                                         if ( redirectOutput )
 115                                                 outWriter.Close();
 116                                         if ( redirectError )
 117                                                 errorWriter.Close();
 118
 119                                         Environment.CurrentDirectory = savedDirectory;
 120                                         Console.SetOut( savedOut );
 121                                         Console.SetError( savedError );
 122                                 }
 123
 124                                 Console.WriteLine();
 125
 126                                 string xmlOutput = CreateXmlOutput( result );
 127
 128                                 if (options.xmlConsole)
 129                                 {
 130                                         Console.WriteLine(xmlOutput);
 131                                 }
 132                                 else
 133                                 {
 134                                         try
 135                                         {
 136                                                 //CreateSummaryDocument(xmlOutput, transformReader );
 137                                                 XmlResultTransform xform = new XmlResultTransform( transformReader );
 138                                                 xform.Transform( new StringReader( xmlOutput ), Console.Out );
 139                                         }
 140                                         catch( Exception ex )
 141                                         {
 142                                                 Console.WriteLine( "Error: {0}", ex.Message );
 143                                                 return TRANSFORM_ERROR;
 144                                         }
 145                                 }
 146
 147                                 // Write xml output here
 148                                 string xmlResultFile = options.xml == null || options.xml == string.Empty
 149                                         ? "TestResult.xml" : options.xml;
 150
 151                                 using ( StreamWriter writer = new StreamWriter( xmlResultFile ) )
 152                                 {
 153                                         writer.Write(xmlOutput);
 154                                 }
 155
 156                                 //if ( testRunner != null )
 157                                 //    testRunner.Unload();
 158
 159                                 if ( collector.HasExceptions )
 160                                 {
 161                                         collector.WriteExceptions();
 162                                         return UNEXPECTED_ERROR;
 163                                 }
 164
 165                                 if ( !result.IsFailure ) return OK;
 166
 167                                 ResultSummarizer summ = new ResultSummarizer( result );
 168                                 return summ.FailureCount;
 169                         }
 170                         finally
 171                         {
 172                                 testRunner.Unload();
 173                         }
 174                 }
 175
 176                 #region Helper Methods
 177                 private static XmlTextReader GetTransformReader(ConsoleOptions parser)
 178                 {
 179                         XmlTextReader reader = null;
 180                         if(parser.transform == null || parser.transform == string.Empty)
 181                         {
 182                                 Assembly assembly = Assembly.GetAssembly(typeof(XmlResultVisitor));
 183                                 ResourceManager resourceManager = new ResourceManager("NUnit.Util.Transform",assembly);
 184                                 string xmlData = (string)resourceManager.GetObject("Summary.xslt");
 185
 186                                 reader = new XmlTextReader(new StringReader(xmlData));
 187                         }
 188                         else
 189                         {
 190                                 FileInfo xsltInfo = new FileInfo(parser.transform);
 191                                 if(!xsltInfo.Exists)
 192                                 {
 193                                         Console.Error.WriteLine("Transform file: {0} does not exist", xsltInfo.FullName);
 194                                         reader = null;
 195                                 }
 196                                 else
 197                                 {
 198                                         reader = new XmlTextReader(xsltInfo.FullName);
 199                                 }
 200                         }
 201
 202                         return reader;
 203                 }
 204
 205                 private static TestRunner MakeRunnerFromCommandLine( ConsoleOptions options )
 206                 {
 207                         TestPackage package;
 208                         ConsoleOptions.DomainUsage domainUsage = ConsoleOptions.DomainUsage.Default;
 209
 210                         if (options.IsTestProject)
 211                         {
 212                                 NUnitProject project = NUnitProject.LoadProject((string)options.Parameters[0]);
 213                                 string configName = options.config;
 214                                 if (configName != null)
 215                                         project.SetActiveConfig(configName);
 216
 217                                 package = project.ActiveConfig.MakeTestPackage();
 218                                 package.TestName = options.fixture;
 219
 220                                 domainUsage = ConsoleOptions.DomainUsage.Single;
 221                         }
 222                         else if (options.Parameters.Count == 1)
 223                         {
 224                                 package = new TestPackage((string)options.Parameters[0]);
 225                                 domainUsage = ConsoleOptions.DomainUsage.Single;
 226                         }
 227                         else
 228                         {
 229                                 package = new TestPackage("UNNAMED", options.Parameters);
 230                                 domainUsage = ConsoleOptions.DomainUsage.Multiple;
 231                         }
 232
 233                         if (options.domain != ConsoleOptions.DomainUsage.Default)
 234                                 domainUsage = options.domain;
 235
 236                         TestRunner testRunner = null;
 237
 238                         switch( domainUsage )
 239                         {
 240                                 case ConsoleOptions.DomainUsage.None:
 241                                         testRunner = new NUnit.Core.RemoteTestRunner();
 242                                         // Make sure that addins are available
 243                                         CoreExtensions.Host.AddinRegistry = Services.AddinRegistry;
 244                                         break;
 245
 246                                 case ConsoleOptions.DomainUsage.Single:
 247                                         testRunner = new TestDomain();
 248                                         break;
 249
 250                                 case ConsoleOptions.DomainUsage.Multiple:
 251                                         testRunner = new MultipleTestDomainRunner();
 252                                         break;
 253                         }
 254
 255                         package.TestName = options.fixture;
 256                         package.Settings["ShadowCopyFiles"] = !options.noshadow;
 257                         package.Settings["UseThreadedRunner"] = !options.nothread;
 258                         testRunner.Load( package );
 259
 260                         return testRunner;
 261                 }
 262
 263                 private static string CreateXmlOutput( TestResult result )
 264                 {
 265                         StringBuilder builder = new StringBuilder();
 266                         XmlResultVisitor resultVisitor = new XmlResultVisitor(new StringWriter( builder ), result);
 267                         result.Accept(resultVisitor);
 268                         resultVisitor.Write();
 269
 270                         return builder.ToString();
 271                 }
 272                 #endregion
 273         }
 274 }
 275