private static int GetExitCodeFromExporter(ProgramOptions options, IContextRunnerConfiguration context)
{
var exporter = GetExporter(options);
int exporterResult = exporter.Export(context, ExportFilenameHelper.GetFilenameForExportConfiguration(exporter, string.Empty, options));
return(exporter.TriggerApplicationExitCode ? exporterResult : 0);
}
protected virtual void Run(IContextRunnerConfiguration configuration)
{
double current = 0;
ReportProgress((int)current, "Starting testconfiguration");
if (configuration.Configurations.Count == 0)
{
ReportError(null, null, new InvalidOperationException("Cannot run a non initialized configuration!"), ResultState.INACTIVE);
return;
}
double step = 100.0 / configuration.Configurations.Count;
foreach (var test in configuration.Configurations)
{
ReportProgress((int)current, string.Format("Running {0}", test.Type.FullName));
try {
RunTest(test);
} catch (Exception ex) {
ReportError(test, null, ex);
} finally {
ClearCache();
}
current += step;
}
ReportProgress((int)current, "Done");
FireDelegate(Completed, null);
}
public void RunAsync(IContextRunnerConfiguration configuration, ManualResetEvent mre)
{
if (_running)
{
mre.Set();
return;
}
lock ( _threadLock ) {
if (_running)
{
mre.Set();
return;
}
_running = true;
}
_workThread = new Thread(obj => {
try {
Console.WriteLine("Starting worker thread");
Run((IContextRunnerConfiguration)obj);
_running = false;
_workThread = null;
} finally {
mre.Set();
}
});
_workThread.Start(configuration);
}
public TestConfiguration(IContextRunnerConfiguration configuration, Type type = null)
{
Completed = false;
_tests = new ObservableCollection <ITestInformation>();
_contextRunnerConfiguration = configuration;
Type = type;
RegisterToCollection(Tests as INotifyCollectionChanged, TestsCollectionChanged, TestInformationChanged);
}
public void CreateConfiguration(IContextRunnerConfiguration configuration, Action callback)
{
Thread configurationThread = new Thread(() => {
try {
Console.WriteLine("Inside analysis");
AnalyzeConfiguration(configuration);
} catch (Exception ex) {
Console.WriteLine(ex.Message);
} finally {
callback();
}
});
Console.WriteLine("Starting configurationThread");
configurationThread.Start();
Console.WriteLine("Calling callback");
}
protected virtual void AnalyzeConfiguration(IContextRunnerConfiguration configuration)
{
var assemblies = configuration.ContextAppDomain.GetAssemblies();
if (assemblies.Length == 0)
{
return;
}
double step = 100.0 / assemblies.Length;
double current = 0;
var loadedAssemblies = new HashSet <AssemblyName>(new AssemblyNameComparer());
foreach (var assembly in assemblies)
{
var testTypeClasses = GetTypesFromAssembly(assembly, loadedAssemblies, configuration);
if (testTypeClasses.Length == 0)
{
current += step;
continue;
}
foreach (var type in testTypeClasses)
{
var methods = type.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
var tInfo = new TestConfiguration(configuration, type);
var definedImplementations = type.GetCustomAttributes <DefineImplementationAttribute>();
if (definedImplementations != null)
{
foreach (var di in definedImplementations)
{
tInfo.DefinedTypes.Add(di.InterfaceType, di.ImplementationType);
}
}
foreach (var method in methods)
{
CheckAndAddMethodMatchingAttribute <AbstractActivatorAttribute>(method, tInfo.Tests);
}
if (tInfo.Tests.Count == 0)
{
continue;
}
configuration.Configurations.Add(tInfo);
}
current += step;
}
}
private static int AnalyzeFailuresAndPrintResults(IContextRunnerConfiguration configuration, ProgramOptions options)
{
int result = 0;
try {
result = GetExitCodeFromExporter(options, configuration);
} catch (Exception ex) {
result = -1;
Console.WriteLine("Error occured in exporter\r\n{0}\r\n{1}", ex.Message, ex.StackTrace);
} finally {
// cleanup
foreach (var item in configuration.Configurations)
{
var disposable = item as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
return(result);
}
public int Export(IContextRunnerConfiguration context, string fileName)
{
int errorCount = 0;
string lastConfigurationName = string.Empty;
var list = GetAllRunInformation(context.Configurations).OrderBy(i => i.Item3.Start).ToList();
foreach (var item in list)
{
if (lastConfigurationName != item.Item1.Type.Name)
{
lastConfigurationName = item.Item1.Type.Name;
if (item.Item1.Failed > 0)
{
WriteError("'{0}' has not completed completely, failed {1}", lastConfigurationName, item.Item1.Failed, item.Item1.Completed);
}
else
{
WriteInfo("'{0}' completed {1} test{2}", lastConfigurationName, item.Item1.Tests.Count, item.Item1.Tests.Count > 0 ? "s" : "");
}
}
if (item.Item3.State == ResultState.SUCCEEDED)
{
WriteSuccess("{0}.{1} completed in {2}", lastConfigurationName, item.Item2.TargetMethod.Name, item.Item3.End.Subtract(item.Item3.Start));
}
else if (item.Item3.State == ResultState.INACTIVE)
{
WriteInfo("{0}.{1} is marked as inactive", lastConfigurationName, item.Item2.TargetMethod.Name);
}
else
{
errorCount++;
WriteError("{0}.{1} exited with stated {2}", lastConfigurationName, item.Item2.TargetMethod.Name, item.Item3.State);
}
}
return(errorCount);
}
protected void LoadAllReferencedAssemblies(Assembly assembly, ISet <AssemblyName> loadedAssemblies, IContextRunnerConfiguration configuration)
{
loadedAssemblies.Add(assembly.GetName());
SetCurrentAssemblyDirectory(assembly);
var referenced = assembly.GetReferencedAssemblies().Where(ass => !loadedAssemblies.Contains(ass));
// loads all referenced assemblies
foreach (var referencedAssemblyName in referenced)
{
if (loadedAssemblies.Contains(referencedAssemblyName))
{
continue;
}
try {
SetCurrentAssemblyNameDirectory(referencedAssemblyName);
LoadAllReferencedAssemblies(configuration.ContextAppDomain.Load(referencedAssemblyName), loadedAssemblies, configuration);
} catch (Exception ex) {
ReportError(null, null, ex);
}
}
}
protected Type[] GetTypesFromAssembly(Assembly assembly, ISet <AssemblyName> loadedAssemblies, IContextRunnerConfiguration configuration)
{
var result = new List <Type>();
try {
SetCurrentAssemblyDirectory(assembly);
LoadAllReferencedAssemblies(assembly, loadedAssemblies, configuration);
var types = assembly.GetTypes();
foreach (var type in types)
{
var attr = type.GetCustomAttribute <TestEnvironmentAttribute>();
if (attr == null || !attr.IsEnabled)
{
continue;
}
result.Add(type);
}
loadedAssemblies.Add(assembly.GetName());
} catch (ReflectionTypeLoadException ex) {
if (ex.LoaderExceptions != null)
{
ReportError(null, null, ex);
}
result.AddRange(ex.Types.Where(type => type != null));
}
return(result.ToArray());
}
