public void GetAssemblyPath_WithHashInDirectoryName()
{
string directoryPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "#HashTestPath");
string originalAssemblyPath = typeof(ReflectionUtilityTest).Assembly.Location;
string newAssemblyPath = Path.Combine(directoryPath, Path.GetFileName(originalAssemblyPath));
if (Directory.Exists(directoryPath))
{
Directory.Delete(directoryPath, true);
}
Directory.CreateDirectory(directoryPath);
try
{
File.Copy(originalAssemblyPath, newAssemblyPath);
AppDomainRunner.Run(
delegate(object[] args)
{
string directory = (string)args[0];
string assemblyPath = (string)args[1];
Assembly assembly = Assembly.LoadFile(assemblyPath);
Assert.That(Path.GetDirectoryName(assembly.Location), Is.EqualTo(directory));
Assert.That(ReflectionUtility.GetAssemblyDirectory(assembly), Is.EqualTo(directory));
},
directoryPath,
newAssemblyPath);
}
finally
{
Directory.Delete(directoryPath, true);
}
}
public void ApplicationAssemblyInclusion_DependsOnAttribute()
{
string compiledAssemblyPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "NonApplicationMarkedAssembly.dll");
try
{
AppDomainRunner.Run(
delegate(object[] args)
{
var path = (string)args[0];
ApplicationAssemblyLoaderFilter filter = ApplicationAssemblyLoaderFilter.Instance;
Assert.That(filter.ShouldIncludeAssembly(typeof(AttributeAssemblyLoaderFilterTest).Assembly), Is.True);
Assert.That(filter.ShouldIncludeAssembly(typeof(TestFixtureAttribute).Assembly), Is.True);
Assert.That(filter.ShouldIncludeAssembly(typeof(ApplicationAssemblyLoaderFilter).Assembly), Is.True);
Assert.That(filter.ShouldIncludeAssembly(typeof(object).Assembly), Is.True);
Assert.That(filter.ShouldIncludeAssembly(typeof(Uri).Assembly), Is.True);
var assemblyCompiler = new AssemblyCompiler(@"Reflection\TypeDiscovery\TestAssemblies\NonApplicationMarkedAssembly", path,
typeof(NonApplicationAssemblyAttribute).Assembly.Location);
assemblyCompiler.Compile();
Assert.That(filter.ShouldIncludeAssembly(assemblyCompiler.CompiledAssembly), Is.False);
}, compiledAssemblyPath);
}
finally
{
if (File.Exists(compiledAssemblyPath))
{
FileUtility.DeleteAndWaitForCompletion(compiledAssemblyPath);
}
}
}
public void Execute()
{
var assembly = request.Container.Location;
var testsToRun = context.GetTestsToRun().ToArray();
var contexts = testsToRun
.Select(x => x.Context.TypeName)
.Distinct();
var cache = new ElementCache(testsToRun);
var tracker = new RunTracker(testsToRun);
var listener = new TestExecutionListener(context, cache, token);
var adapter = new ExecutionAdapterRunListener(listener, cache, tracker);
var loggingListener = new LoggingRunListener(adapter);
var machineAdapter = new AdapterListener(loggingListener, assembly);
var runOptions = RunOptions.Custom.FilterBy(contexts);
var runner = new AppDomainRunner(machineAdapter, runOptions);
runner.RunAssembly(new AssemblyPath(request.Container.Location));
listener.Finished.WaitOne();
}
private static void RunInAppDomain(IFrameworkHandle frameworkHandle, IGrouping <string, TestCase> source, List <TestCase> tests)
{
var dir = Path.GetDirectoryName(source.Key);
var cmd = new RunTests
{
AssemblyName = Path.GetFileName(source.Key), AssemblyPath = dir, Source = source.Key,
};
var dto = new List <TestCaseToRun>();
foreach (TestCase testCase in tests)
{
var parts = testCase.FullyQualifiedName.Split('.');
dto.Add(new TestCaseToRun(testCase.FullyQualifiedName)
{
TestClassName = parts[parts.Length - 2],
TestMethodName = parts[parts.Length - 1]
});
}
using (var appDomainRunner = new AppDomainRunner(source.Key))
{
appDomainRunner.AddDirectory(dir);
appDomainRunner.Create();
var resultProxy = new TestResultProxy(frameworkHandle, tests);
appDomainRunner.RunTests(cmd, resultProxy);
}
}
public void DoesntChangeCurrentSetup()
{
string dynamicBaseBefore = AppDomain.CurrentDomain.SetupInformation.DynamicBase;
AppDomainRunner.Run(delegate { new AppDomainRunnerTest(); });
Assert.That(AppDomain.CurrentDomain.SetupInformation.DynamicBase, Is.EqualTo(dynamicBaseBefore));
}
public void SpecificAppBase()
{
AppDomainRunner.Run(@"C:\", delegate(object[] args)
{
Assert.That(AppDomain.CurrentDomain.BaseDirectory, Is.EqualTo(@"C:\"));
});
}
/// <summary>
/// Executes the task.
/// </summary>
protected override void ExecuteTask()
{
DisplayTaskConfiguration();
if (FileSetHelper.Count(Assemblies) == 0)
{
Log(Level.Warning, "No specification assemblies, aborting task");
return;
}
List <ISpecificationRunListener> listeners = SetUpListeners();
NAntRunListener nantRunListener = new NAntRunListener(this);
listeners.Add(nantRunListener);
AggregateRunListener rootListener = new AggregateRunListener(listeners);
ISpecificationRunner runner = new AppDomainRunner(rootListener, RunOptions.Default);
RunSpecifications(Assemblies, runner);
Log(Level.Info, "Finished running specs");
if (nantRunListener.FailureOccurred)
{
throw new BuildException("There were failing specifications. Please see the build log.");
}
}
public void Run(TestContext context)
{
var environment = new TestEnvironment(context.AssemblyTask);
var listener = new TestRunListener(_taskServer, context);
var runOptions = RunOptions.Custom.FilterBy(context.GetContextNames());
if (environment.ShouldShadowCopy)
{
runOptions.ShadowCopyTo(environment.ShadowCopyPath);
_taskServer.SetTempFolderPath(environment.ShadowCopyPath);
}
var appDomainRunner = new AppDomainRunner(listener, runOptions);
try
{
appDomainRunner.RunAssembly(new AssemblyPath(environment.AssemblyPath));
}
catch (Exception e)
{
_taskServer.ShowNotification("Unable to run tests: " + e.Message, string.Empty);
_taskServer.TaskException(context.AssemblyTask, new[] { new TaskException(e) });
}
}
public void GetDefaultQueryFilePath_ThrowsIfNoQueryFileExists()
{
AppDomainRunner.Run(@"C:\", delegate
{
QueryConfiguration configuration = new QueryConfiguration();
configuration.GetDefaultQueryFilePath();
});
}
public TestRunState RunMember(ITestListener testListener, Assembly assembly, MemberInfo member)
{
var listener = new TDNetRunListener(testListener);
var runner = new AppDomainRunner(listener, RunOptions.Default);
runner.RunMember(assembly, member);
return(listener.TestRunState);
}
public TestRunState RunNamespace(ITestListener testListener, Assembly assembly, string ns)
{
var listener = new TDNetRunListener(testListener);
var runner = new AppDomainRunner(listener, RunOptions.Default);
runner.RunNamespace(assembly, ns);
return(listener.TestRunState);
}
public TestRunState RunAssembly(ITestListener testListener, Assembly assembly)
{
var listener = new TDNetRunListener(testListener);
var runner = new AppDomainRunner(listener, RunOptions.Default);
runner.RunAssembly(new AssemblyPath(assembly.Location));
return(listener.TestRunState);
}
public IEnumerable<TestResult> Run(RunSettings settings)
{
_results = new List<TestResult>();
var listener = new TestListener(_feedback, settings.Assembly.Assembly);
var assembly = getAssembly(settings.Assembly.Assembly);
var runner = new AppDomainRunner(listener, Machine.Specifications.Runner.RunOptions.Default);
runTests(settings, assembly, runner);
_results.AddRange(listener.Results);
return _results;
}
public void AppDomainIsCreated()
{
AppDomain current = AppDomain.CurrentDomain;
AppDomainRunner.Run(
delegate(object[] args)
{
Assert.That(AppDomain.CurrentDomain.FriendlyName, Is.EqualTo("AppDomainRunner - AppDomain"));
Assert.That(AppDomain.CurrentDomain, Is.Not.SameAs(args[0]));
},
current);
}
/// <summary>
/// Evaluates the chromosome's fitness.
/// </summary>
public override async Task EvaluateAsync(IChromosome chromosome)
{
try
{
// cast to the base type
var chromosomeBase = (Chromosome)chromosome;
// Convert to dictionary and add "id" key-value pair
var list = chromosomeBase.ToDictionary();
list.Add("chromosome-id", chromosomeBase.Id);
// Set algorithm start and end dates
list.Add("start-date", StartDate.ToString("O"));
list.Add("end-date", EndDate.ToString("O"));
// Additional settings to the list
list.Add("algorithm-type-name", Shared.Config.AlgorithmTypeName);
list.Add("algorithm-location", Shared.Config.AlgorithmLocation);
list.Add("data-folder", Shared.Config.DataFolder);
// Obtain full results
var result = await Task.Run(() => AppDomainRunner.RunAlgorithm(list));
// Calculate fitness and concat the results with an output string
var fitness = StatisticsAdapter.CalculateFitness(result, FitnessScore, FilterEnabled);
// Save full results
chromosomeBase.FitnessResult = new FitnessResult
{
Chromosome = chromosomeBase,
StartDate = this.StartDate,
EndDate = this.EndDate,
FullResults = result
};
// create an output string
var theOutput = chromosomeBase.EvaluationToLogOutput(result, FitnessScore, fitness);
// Display the output
lock (_lock)
{
Shared.Logger.Trace(theOutput + Environment.NewLine);
}
// assign a value to chromosome fitness
chromosome.Fitness = fitness;
}
catch (Exception ex)
{
Shared.Logger.Error("OptimizerFitness.Evaluate: " + ex.Message);
}
}
public void ArgumentsArePassedInCorrectly()
{
AppDomainRunner.Run(delegate(object[] args)
{
Assert.That(args.Length, Is.EqualTo(2));
Assert.That("Foo", Is.EqualTo(args[0]));
Assert.That(4, Is.EqualTo(args[1]));
}, "Foo", 4);
AppDomainRunner.Run(delegate(object[] args)
{
Assert.That(args.Length, Is.EqualTo(0));
});
}
private void runTests(RunSettings settings, Assembly assembly, AppDomainRunner runner)
{
if (runAllTests(settings))
{
runner.RunAssembly(assembly);
return;
}
foreach (var member in settings.Assembly.Tests)
runner.RunMember(assembly, assembly.GetType(member));
foreach (var member in settings.Assembly.Members)
runner.RunMember(assembly, assembly.GetType(member));
foreach (var ns in settings.Assembly.Namespaces)
runner.RunNamespace(assembly, ns);
}
public TestRunState RunAssembly(ITestListener testListener, Assembly assembly)
{
var listener = new TDNetRunListener(testListener);
var runner = new AppDomainRunner(listener, RunOptions.Default);
try
{
runner.StartRun(assembly);
runner.RunAssembly(assembly);
}
finally
{
runner.EndRun(assembly);
}
return(listener.TestRunState);
}
/// <summary>
/// Inits computation resources
/// </summary>
public static void Initialize()
{
// Computation mode specific settings: azure or app domain ?
switch (Shared.Config.TaskExecutionMode)
{
case TaskExecutionMode.Azure:
AzureBatchManager.InitializeAsync().Wait();
break;
case TaskExecutionMode.Linear:
case TaskExecutionMode.Parallel:
AppDomainRunner.Initialize();
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private static ExitCode RunAssembly(Assembly assembly, RunOptions runOptions)
{
ISpecificationRunListener listener = new BufferedAssemblyTeamCityReporter(WriteToTeamCity);
ISpecificationRunner specificationRunner = new AppDomainRunner(listener, runOptions);
specificationRunner.RunAssembly(assembly);
if (listener is ISpecificationResultProvider)
{
var errorProvider = (ISpecificationResultProvider)listener;
if (errorProvider.FailureOccurred)
{
return(ExitCode.Failure);
}
}
return(ExitCode.Success);
}
/// <summary>
/// Releases the computation resources at the end of optimization routine
/// </summary>
public static void Dispose()
{
// -1- Clean up Task Execution resources
switch (Shared.Config.TaskExecutionMode)
{
case TaskExecutionMode.Azure:
AzureBatchManager.DisposeAsync().Wait();
break;
case TaskExecutionMode.Linear:
case TaskExecutionMode.Parallel:
// -2- Release AppDomain
AppDomainRunner.Dispose();
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public void FindAssemblies_FindsReferencedAssemblies_Transitive()
{
const string buildOutputDirectory = "Reflection.AssemblyFinderTest.FindAssemblies_FindsReferencedAssemblies_Transitive";
const string sourceDirectoryRoot = @"Reflection\TypeDiscovery\AssemblyFinding\TestAssemblies\AssemblyFinderTest";
Action <object[]> testAction = delegate(object[] args)
{
var outputManagerWithoutClosure = (AssemblyCompilerBuildOutputManager)args[0];
// dependency chain: mixinSamples -> remotion -> log4net
var log4NetAssembly = typeof(log4net.LogManager).Assembly;
var remotionAssembly = typeof(AssemblyFinder).Assembly;
var referencingAssembly = CompileReferencingAssembly(outputManagerWithoutClosure, remotionAssembly);
var loaderMock = MockRepository.GenerateMock <IAssemblyLoader>();
loaderMock
.Expect(mock => mock.TryLoadAssembly(ArgReferenceMatchesDefinition(remotionAssembly), Arg.Is(referencingAssembly.FullName)))
// load re-motion via samples
.Return(remotionAssembly);
loaderMock
.Expect(mock => mock.TryLoadAssembly(ArgReferenceMatchesDefinition(log4NetAssembly), Arg.Is(remotionAssembly.FullName)))
// load log4net via re-motion
.Return(log4NetAssembly);
loaderMock.Replay();
var rootAssemblyFinderStub = MockRepository.GenerateMock <IRootAssemblyFinder>();
rootAssemblyFinderStub.Stub(stub => stub.FindRootAssemblies()).Return(
new[] { new RootAssembly(referencingAssembly, true) });
rootAssemblyFinderStub.Replay();
var finder = new AssemblyFinder(rootAssemblyFinderStub, loaderMock);
var result = finder.FindAssemblies();
loaderMock.VerifyAllExpectations();
Assert.That(result, Is.EquivalentTo(new[] { referencingAssembly, remotionAssembly, log4NetAssembly }));
};
// Run test action in separate AppDomain
using (var outputManager = new AssemblyCompilerBuildOutputManager(buildOutputDirectory, true, sourceDirectoryRoot))
{
AppDomainRunner.Run(testAction, outputManager);
}
}
public override void ExecuteRecursive(TaskExecutionNode node)
{
var task = (RunAssemblyTask)node.RemoteTask;
var contextAssembly = LoadContextAssembly(task);
if (contextAssembly == null)
{
return;
}
var result = VersionCompatibilityChecker.Check(contextAssembly);
if (!result.Success)
{
Server.TaskException(node.RemoteTask, new[] { new TaskException("no type", result.ErrorMessage, null) });
return;
}
var listener = new PerAssemblyRunListener(Server, task);
var runner = new AppDomainRunner(listener, RunOptions.Default);
var runScope = GetRunScope(runner);
node.Flatten(x => x.Children).Each(children => RegisterRemoteTaskNotifications(listener, children));
try
{
runScope.StartRun(contextAssembly);
foreach (var child in node.Children)
{
RunContext(runner, contextAssembly, child);
}
}
finally
{
runScope.EndRun(contextAssembly);
}
}
public void SavesMixedTypes()
{
AppDomainRunner.Run(
delegate
{
using (MixinConfiguration.BuildNew()
.ForClass <BaseType1>().AddMixins(typeof(BT1Mixin1))
.ForClass <Page> ().AddMixin(typeof(NullMixin))
.EnterScope())
{
Mixer mixer = Mixer.Create("Assembly", _assemblyOutputDirectory, 1);
mixer.PrepareOutputDirectory();
mixer.Execute(MixinConfiguration.ActiveConfiguration);
Assembly theAssembly = Assembly.LoadFile(mixer.MixerPipelineFactory.GetModulePaths(_assemblyOutputDirectory).Single());
var types = theAssembly.GetTypes();
var concreteType = types.SingleOrDefault(t => t.BaseType == typeof(BaseType1));
Assert.NotNull(concreteType);
Assert.That(
MixinTypeUtility.GetClassContextForConcreteType(concreteType),
Is.EqualTo(MixinConfiguration.ActiveConfiguration.GetContext(typeof(BaseType1))));
object instance = Activator.CreateInstance(concreteType);
Assert.That(Mixin.Get <BT1Mixin1> (instance), Is.Not.Null);
var concreteTypeFromSystemAssembly = types.SingleOrDefault(t => t.BaseType == typeof(Page));
Assert.That(concreteTypeFromSystemAssembly, Is.Not.Null);
SafeServiceLocator.Current.GetInstance <IPipelineRegistry>().DefaultPipeline.CodeManager.LoadFlushedCode(theAssembly);
Type concreteTypeFromFactory = TypeFactory.GetConcreteType(typeof(BaseType1));
Assert.That(concreteTypeFromFactory, Is.SameAs(concreteType));
Assert.That(theAssembly.IsDefined(typeof(NonApplicationAssemblyAttribute), false), Is.True);
}
});
}
public override void ExecuteRecursive(TaskExecutionNode node)
{
var task = (RunAssemblyTask)node.RemoteTask;
var priorCurrentDirectory = Environment.CurrentDirectory;
try
{
// Use the assembly in the folder that the user has specified, or, if not, use the assembly location
var assemblyFolder = GetAssemblyFolder(TaskExecutor.Configuration, task);
var assemblyPath = new AssemblyPath(Path.Combine(assemblyFolder, GetFileName(task.AssemblyLocation)));
Environment.CurrentDirectory = assemblyFolder;
var listener = new PerAssemblyRunListener(Server, task);
var contextList = new List <string>();
node.Flatten(x => x.Children).Each(children => RegisterRemoteTaskNotifications(listener, children, contextList));
var runOptions = RunOptions.Custom.FilterBy(contextList);
var appDomainRunner = new AppDomainRunner(listener, runOptions);
if (TaskExecutor.Configuration.ShadowCopy)
{
string cachePath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
runOptions.ShadowCopyTo(cachePath);
this.Server.SetTempFolderPath(cachePath);
}
appDomainRunner.RunAssembly(assemblyPath);
}
finally
{
Environment.CurrentDirectory = priorCurrentDirectory;
}
}
static async Task Main(string[] args)
{
var discoverer = new TestDiscoverer();
discoverer.Load(new[] { typeof(IncidentWrapper).Assembly });
var runner = new TestRunner(discoverer);
runner.Load(new[] { typeof(IncidentWrapper).Assembly }).GetAwaiter().GetResult();
var result = runner.RunAll().GetAwaiter().GetResult();
var faulty = result.Where(x => !x.IsSuccess).ToList();
var cmd = new RunTests
{
AssemblyName = typeof(EnvironmentTests).Assembly.GetName().Name,
AssemblyPath = Path.GetDirectoryName(typeof(EnvironmentTests).Assembly.Location),
//TestCases = new[]
//{
// new TestCaseToRun("Coderr.IntegrationTests.Core.TestCases.EnvironmentTests.Clearing_environment_should_remove_all_incidents_in_it")
// {
// TestClassName = "EnvironmentTests",
// TestMethodName = "Clearing_environment_should_remove_all_incidents_in_it"
// },
//},
Source = typeof(EnvironmentTests).Assembly.Location
};
var receiver = new ConsoleReceiver();
using (var coordinator = new AppDomainRunner("TesTSuite1"))
{
coordinator.Create();
coordinator.AddDirectory(
@"C:\src\1tcompany\coderr\oss\Coderr.Server\src\Tools\Coderr.IntegrationTests\Coderr.IntegrationTests\bin\Debug\net461");
coordinator.RunTests(cmd, receiver);
}
}
public ExitCode Run(string[] arguments)
{
ExceptionReporter reporter = new ExceptionReporter(_console);
Options options = new Options();
if (!options.ParseArguments(arguments))
{
_console.WriteLine(Options.Usage());
return(ExitCode.Failure);
}
List <ISpecificationRunListener> listeners = new List <ISpecificationRunListener>();
var timingListener = new TimingRunListener();
listeners.Add(timingListener);
listeners.Add(new AssemblyLocationAwareListener());
ISpecificationRunListener mainListener;
if (options.TeamCityIntegration ||
(!options.DisableTeamCityAutodetection &&
Environment.GetEnvironmentVariable("TEAMCITY_PROJECT_NAME") != null))
{
mainListener = new TeamCityReporter(_console.WriteLine, timingListener);
}
else
{
mainListener = new RunListener(_console, options.Silent, timingListener);
}
try
{
if (!String.IsNullOrEmpty(options.HtmlPath))
{
if (IsHtmlPathValid(options.HtmlPath))
{
listeners.Add(GetHtmlReportListener(options));
}
else
{
_console.WriteLine("Invalid html path:" + options.HtmlPath);
_console.WriteLine(Options.Usage());
return(ExitCode.Failure);
}
}
if (!String.IsNullOrEmpty(options.XmlPath))
{
if (IsHtmlPathValid(options.XmlPath))
{
listeners.Add(GetXmlReportListener(options, timingListener));
}
else
{
_console.WriteLine("Invalid xml path:" + options.XmlPath);
_console.WriteLine(Options.Usage());
return(ExitCode.Failure);
}
}
listeners.Add(mainListener);
if (options.AssemblyFiles.Count == 0)
{
_console.WriteLine(Options.Usage());
return(ExitCode.Failure);
}
var listener = new AggregateRunListener(listeners);
ISpecificationRunner specificationRunner = new AppDomainRunner(listener, options.GetRunOptions());
List <Assembly> assemblies = new List <Assembly>();
foreach (string assemblyName in options.AssemblyFiles)
{
if (!File.Exists(assemblyName))
{
throw NewException.MissingAssembly(assemblyName);
}
Assembly assembly = Assembly.LoadFrom(assemblyName);
assemblies.Add(assembly);
}
if (options.WaitForDebugger)
{
WaitForDebugger();
if (Debugger.IsAttached == false)
{
_console.WriteLine("Fatal error: Timeout while waiting for debugger to attach");
return(ExitCode.Failure);
}
}
specificationRunner.RunAssemblies(assemblies);
}
catch (Exception ex)
{
reporter.ReportException(ex);
return(ExitCode.Error);
}
if (mainListener is ISpecificationResultProvider)
{
var errorProvider = (ISpecificationResultProvider)mainListener;
if (errorProvider.FailureOccurred)
{
return(ExitCode.Failure);
}
}
return(ExitCode.Success);
}
public ExitCode Run(string[] arguments)
{
ExceptionReporter reporter = new ExceptionReporter(_console);
Options options = new Options();
if (!options.ParseArguments(arguments))
{
_console.WriteLine(Resources.UsageStatement);
return ExitCode.Failure;
}
List<ISpecificationRunListener> listeners = new List<ISpecificationRunListener>();
var timingListener = new TimingRunListener();
listeners.Add(timingListener);
listeners.Add(new AssemblyLocationAwareListener());
ISpecificationRunListener mainListener;
if (options.TeamCityIntegration)
{
mainListener = new TeamCityReporter(_console.WriteLine, timingListener);
}
else
{
mainListener = new RunListener(_console, options.Silent, timingListener);
}
try
{
if (SetupCustomListeners(options, listeners, timingListener))
{
return ExitCode.Failure;
}
listeners.Add(mainListener);
if (options.AssemblyFiles.Count == 0)
{
_console.WriteLine(Resources.UsageStatement);
return ExitCode.Failure;
}
var listener = new AggregateRunListener(listeners);
ISpecificationRunner specificationRunner = new AppDomainRunner(listener, options.GetRunOptions());
List<Assembly> assemblies = new List<Assembly>();
foreach (string assemblyName in options.AssemblyFiles)
{
if (!File.Exists(assemblyName))
{
throw NewException.MissingAssembly(assemblyName);
}
Assembly assembly = Assembly.LoadFrom(assemblyName);
assemblies.Add(assembly);
}
specificationRunner.RunAssemblies(assemblies);
}
catch (Exception ex)
{
reporter.ReportException(ex);
return ExitCode.Error;
}
if (mainListener is ISpecificationResultProvider)
{
var errorProvider = (ISpecificationResultProvider)mainListener;
if (errorProvider.FailureOccurred)
{
return ExitCode.Failure;
}
}
return ExitCode.Success;
}
public ExitCode Run(string[] arguments)
{
ExceptionReporter reporter = new ExceptionReporter(_console);
Options options = new Options();
if (!options.ParseArguments(arguments))
{
_console.WriteLine(Options.Usage());
return(ExitCode.Failure);
}
List <ISpecificationRunListener> listeners = new List <ISpecificationRunListener>();
var timingListener = new TimingRunListener();
listeners.Add(timingListener);
listeners.Add(new AssemblyLocationAwareListener());
ISpecificationRunListener mainListener;
if (options.TeamCityIntegration)
{
mainListener = new TeamCityReporter(_console.WriteLine, timingListener);
}
else
{
mainListener = new RunListener(_console, options.Silent, timingListener);
}
try
{
if (!String.IsNullOrEmpty(options.HtmlPath))
{
if (IsHtmlPathValid(options.HtmlPath))
{
listeners.Add(GetHtmlReportListener(options));
}
else
{
_console.WriteLine("Invalid html path:" + options.HtmlPath);
_console.WriteLine(Options.Usage());
return(ExitCode.Failure);
}
}
if (!String.IsNullOrEmpty(options.XmlPath))
{
if (IsHtmlPathValid(options.XmlPath))
{
listeners.Add(GetXmlReportListener(options, timingListener));
}
else
{
_console.WriteLine("Invalid xml path:" + options.XmlPath);
_console.WriteLine(Options.Usage());
return(ExitCode.Failure);
}
}
listeners.Add(mainListener);
if (options.AssemblyFiles.Count == 0)
{
_console.WriteLine(Options.Usage());
return(ExitCode.Failure);
}
var listener = new AggregateRunListener(listeners);
ISpecificationRunner specificationRunner = new AppDomainRunner(listener, options.GetRunOptions());
List <Assembly> assemblies = new List <Assembly>();
foreach (string assemblyName in options.AssemblyFiles)
{
if (!File.Exists(assemblyName))
{
throw NewException.MissingAssembly(assemblyName);
}
Assembly assembly = Assembly.LoadFrom(assemblyName);
assemblies.Add(assembly);
}
specificationRunner.RunAssemblies(assemblies);
}
catch (Exception ex)
{
reporter.ReportException(ex);
return(ExitCode.Error);
}
if (mainListener is ISpecificationResultProvider)
{
var errorProvider = (ISpecificationResultProvider)mainListener;
if (errorProvider.FailureOccurred)
{
return(ExitCode.Failure);
}
}
return(ExitCode.Success);
}
static void Main(string[] args)
{
AppDomainRunner.Marshalling();
}
public ExitCode Run(string[] arguments)
{
ExceptionReporter reporter = new ExceptionReporter(_console);
Options options = new Options();
if (!options.ParseArguments(arguments))
{
_console.WriteLine(Options.Usage());
return(ExitCode.Failure);
}
var timer = new TimingRunListener();
var listeners = new List <ISpecificationRunListener>
{
timer
};
ISpecificationRunListener mainListener;
if (options.TeamCityIntegration ||
(!options.DisableTeamCityAutodetection &&
Environment.GetEnvironmentVariable("TEAMCITY_PROJECT_NAME") != null))
{
mainListener = new TeamCityReporter(_console.WriteLine, timer);
}
else
{
mainListener = new RunListener(_console, DetermineOutput(options, _console), timer);
}
try
{
if (!String.IsNullOrEmpty(options.HtmlPath))
{
if (IsHtmlPathValid(options.HtmlPath))
{
listeners.Add(GetHtmlReportListener(options));
}
else
{
_console.WriteLine("Invalid html path: {0}", options.HtmlPath);
_console.WriteLine(Options.Usage());
return(ExitCode.Failure);
}
}
if (!String.IsNullOrEmpty(options.XmlPath))
{
if (IsHtmlPathValid(options.XmlPath))
{
listeners.Add(GetXmlReportListener(options, timer));
}
else
{
_console.WriteLine("Invalid xml path: {0}", options.XmlPath);
_console.WriteLine(Options.Usage());
return(ExitCode.Failure);
}
}
listeners.Add(mainListener);
if (options.AssemblyFiles.Count == 0)
{
_console.WriteLine(Options.Usage());
return(ExitCode.Failure);
}
var listener = new AggregateRunListener(listeners);
ISpecificationRunner specificationRunner = new AppDomainRunner(listener, options.GetRunOptions());
List <Assembly> assemblies = new List <Assembly>();
foreach (string assemblyName in options.AssemblyFiles)
{
if (!File.Exists(assemblyName))
{
throw NewException.MissingAssembly(assemblyName);
}
var excludedAssemblies = new[] { "Machine.Specifications.dll", "Machine.Specifications.Clr4.dll" };
if (excludedAssemblies.Any(x => Path.GetFileName(assemblyName) == x))
{
_console.WriteLine("Warning: Excluded {0} from the test run because the file name matches either of these: {1}", assemblyName, String.Join(", ", excludedAssemblies));
continue;
}
Assembly assembly = Assembly.LoadFrom(assemblyName);
assemblies.Add(assembly);
}
if (options.WaitForDebugger)
{
WaitForDebugger();
if (Debugger.IsAttached == false)
{
_console.WriteLine("Fatal error: Timeout while waiting for debugger to attach");
return(ExitCode.Failure);
}
}
specificationRunner.RunAssemblies(assemblies);
}
catch (Exception ex)
{
reporter.ReportException(ex);
return(ExitCode.Error);
}
if (mainListener is ISpecificationResultProvider)
{
var errorProvider = (ISpecificationResultProvider)mainListener;
if (errorProvider.FailureOccurred)
{
return(ExitCode.Failure);
}
}
return(ExitCode.Success);
}
