public TestRunnerWindow(IMouseRobot MouseRobot, ITestRunnerManager TestRunnerManager, ITestRunner TestRunner)
{
this.MouseRobot = MouseRobot;
this.TestRunnerManager = TestRunnerManager;
this.TestRunner = TestRunner;
InitializeComponent();
AutoScaleMode = AutoScaleMode.Dpi;
treeListView.Font = Fonts.Default;
TestRunnerManager.TestFixtureAdded += OnTestFixtureAdded;
TestRunnerManager.TestFixtureRemoved += OnTestFixtureRemoved;
TestRunnerManager.TestFixtureModified += OnTestFixtureModified;
TestRunnerManager.TestStatusUpdated += UpdateTestStatusIconsAsync;
TestRunner.TestRunEnd += OnTestRunEnd;
TestRunner.FixtureIsBeingRun += OnFixtureIsBeingRun;
TestRunner.TestIsBeingRun += OnTestIsBeingRun;
MouseRobot.PlayingStateChanged += OnPlayingStateChanged;
treeListView.HandleCreated += (sender, args) => UpdateHierarchyAsync();
CreateColumns();
UpdateHierarchyAsync();
}
protected override void ShowHelp()
{
// Show argument only help first because what we do next might take a little while
// and we want to make the program appear responsive.
base.ShowHelp();
// Print out options related to the currently available set of plugins.
var setup = new RuntimeSetup();
if (Arguments != null && Arguments.PluginDirectories != null)
{
GenericCollectionUtils.ForEach(Arguments.PluginDirectories, x => setup.AddPluginDirectory(x));
}
using (RuntimeBootstrap.Initialize(setup, CreateLogger()))
{
IReportManager reportManager = RuntimeAccessor.ServiceLocator.Resolve <IReportManager>();
ShowRegisteredComponents("Supported report types:", reportManager.FormatterHandles,
h => h.GetTraits().Name, h => h.GetTraits().Description);
ITestRunnerManager runnerManager = RuntimeAccessor.ServiceLocator.Resolve <ITestRunnerManager>();
ShowRegisteredComponents("Supported runner types:", runnerManager.TestRunnerFactoryHandles,
h => h.GetTraits().Name, h => h.GetTraits().Description);
}
}
private void RunAllTests(IRunContext runContext)
{
ITestRunnerManager runnerManager = RuntimeAccessor.ServiceLocator.Resolve <ITestRunnerManager>();
var runner = runnerManager.CreateTestRunner(StandardTestRunnerFactoryNames.IsolatedAppDomain);
runner.RegisterExtension(new RunContextExtension(runContext));
ILogger logger = new RunContextLogger(runContext);
TestRunnerOptions testRunnerOptions = new TestRunnerOptions();
try
{
RunWithProgressMonitor(delegate(IProgressMonitor progressMonitor)
{
runner.Initialize(testRunnerOptions, logger, progressMonitor);
});
if (isCanceled)
{
return;
}
TestPackage testPackage = new TestPackage();
testPackage.AddExcludedTestFrameworkId("MSTestAdapter.TestFramework");
foreach (ITestElement testElement in runContext.RunConfig.TestElements)
{
GallioTestElement gallioTestElement = testElement as GallioTestElement;
if (gallioTestElement != null)
{
testPackage.AddFile(new FileInfo(gallioTestElement.AssemblyPath));
}
}
TestExplorationOptions testExplorationOptions = new TestExplorationOptions();
TestExecutionOptions testExecutionOptions = new TestExecutionOptions();
List <Filter <string> > idFilters = new List <Filter <string> >();
foreach (ITestElement includedTestElement in runContext.RunConfig.TestElements)
{
GallioTestElement gallioTestElement = includedTestElement as GallioTestElement;
if (gallioTestElement != null)
{
idFilters.Add(new EqualityFilter <string>(gallioTestElement.GallioTestId));
}
}
testExecutionOptions.FilterSet = new FilterSet <ITestDescriptor>(new IdFilter <ITestDescriptor>(new OrFilter <string>(idFilters)));
RunWithProgressMonitor(delegate(IProgressMonitor progressMonitor)
{
runner.Run(testPackage, testExplorationOptions, testExecutionOptions, progressMonitor);
});
}
finally
{
runner.Dispose(NullProgressMonitor.CreateInstance());
}
}
internal static void Reset()
{
if (Instance is IDisposable)
{
((IDisposable)Instance).Dispose();
}
Instance = new TestRunnerManager();
}
public static void BeforeTestRunInjection(ITestRunnerManager testRunnerManager, ITestRunner testRunner)
{
//All parameters are resolved from the test thread container automatically.
//Since the global container is the base container of the test thread container, globally registered services can be also injected.
//ITestRunManager from global container
var location = testRunnerManager.TestAssembly.Location;
//ITestRunner from test thread container
var threadId = testRunner.ThreadId;
Console.WriteLine($"Location: {location}; ThreadId: {threadId}");
}
public TestExecutionEngine(
IStepFormatter stepFormatter,
ITestTracer testTracer,
IErrorProvider errorProvider,
IStepArgumentTypeConverter stepArgumentTypeConverter,
SpecFlowConfiguration specFlowConfiguration,
IBindingRegistry bindingRegistry,
IUnitTestRuntimeProvider unitTestRuntimeProvider,
IContextManager contextManager,
IStepDefinitionMatchService stepDefinitionMatchService,
IDictionary <string, IStepErrorHandler> stepErrorHandlers,
IBindingInvoker bindingInvoker,
IObsoleteStepHandler obsoleteStepHandler,
ICucumberMessageSender cucumberMessageSender,
ITestResultFactory testResultFactory,
ITestPendingMessageFactory testPendingMessageFactory,
ITestUndefinedMessageFactory testUndefinedMessageFactory,
ITestRunResultCollector testRunResultCollector,
IAnalyticsEventProvider analyticsEventProvider,
IAnalyticsTransmitter analyticsTransmitter,
ITestRunnerManager testRunnerManager,
IRuntimePluginTestExecutionLifecycleEventEmitter runtimePluginTestExecutionLifecycleEventEmitter,
ITestObjectResolver testObjectResolver = null,
IObjectContainer testThreadContainer = null) //TODO: find a better way to access the container
{
_errorProvider = errorProvider;
_bindingInvoker = bindingInvoker;
_contextManager = contextManager;
_unitTestRuntimeProvider = unitTestRuntimeProvider;
_bindingRegistry = bindingRegistry;
_specFlowConfiguration = specFlowConfiguration;
_testTracer = testTracer;
_stepFormatter = stepFormatter;
_stepArgumentTypeConverter = stepArgumentTypeConverter;
_stepErrorHandlers = stepErrorHandlers?.Values.ToArray();
_stepDefinitionMatchService = stepDefinitionMatchService;
_testObjectResolver = testObjectResolver;
TestThreadContainer = testThreadContainer;
_obsoleteStepHandler = obsoleteStepHandler;
_cucumberMessageSender = cucumberMessageSender;
_testResultFactory = testResultFactory;
_testPendingMessageFactory = testPendingMessageFactory;
_testUndefinedMessageFactory = testUndefinedMessageFactory;
_testRunResultCollector = testRunResultCollector;
_analyticsEventProvider = analyticsEventProvider;
_analyticsTransmitter = analyticsTransmitter;
_testRunnerManager = testRunnerManager;
_runtimePluginTestExecutionLifecycleEventEmitter = runtimePluginTestExecutionLifecycleEventEmitter;
}
public GhprTestExecutionEngine(
IStepFormatter stepFormatter,
ITestTracer testTracer,
IErrorProvider errorProvider,
IStepArgumentTypeConverter stepArgumentTypeConverter,
SpecFlowConfiguration specFlowConfiguration,
IBindingRegistry bindingRegistry,
IUnitTestRuntimeProvider unitTestRuntimeProvider,
IContextManager contextManager,
IStepDefinitionMatchService stepDefinitionMatchService,
IDictionary <string, IStepErrorHandler> stepErrorHandlers,
IBindingInvoker bindingInvoker,
IObsoleteStepHandler obsoleteStepHandler,
ICucumberMessageSender cucumberMessageSender,
ITestResultFactory testResultFactory,
ITestPendingMessageFactory testPendingMessageFactory,
ITestUndefinedMessageFactory testUndefinedMessageFactory,
ITestRunResultCollector testRunResultCollector,
IAnalyticsEventProvider analyticsEventProvider,
IAnalyticsTransmitter analyticsTransmitter,
ITestRunnerManager testRunnerManager,
ITestObjectResolver testObjectResolver = null,
IObjectContainer testThreadContainer = null)
{
_engine = new TestExecutionEngine(stepFormatter,
testTracer,
errorProvider,
stepArgumentTypeConverter,
specFlowConfiguration,
bindingRegistry,
unitTestRuntimeProvider,
contextManager,
stepDefinitionMatchService,
stepErrorHandlers,
bindingInvoker,
obsoleteStepHandler,
cucumberMessageSender,
testResultFactory,
testPendingMessageFactory,
testUndefinedMessageFactory,
testRunResultCollector,
analyticsEventProvider,
analyticsTransmitter,
testRunnerManager,
testObjectResolver,
testThreadContainer);
}
public void Initialize()
{
var container = new UnityContainer();
RobotRuntime.Program.RegisterInterfaces(container);
Robot.Program.RegisterInterfaces(container);
container.RegisterType <ILogger, FakeLogger>(new ContainerControlledLifetimeManager());
Logger.Instance = container.Resolve <ILogger>();
MouseRobot = container.Resolve <IMouseRobot>();
var ProjectManager = container.Resolve <IProjectManager>();
AssetManager = container.Resolve <IAssetManager>();
TestRunnerManager = container.Resolve <ITestRunnerManager>();
TestFixtureManager = container.Resolve <ITestFixtureManager>();
ProjectManager.InitProject(TempProjectPath);
}
private TestRunner InitTestRunner()
{
//TestRunnerManager.GetTestRunner(); //without "BeforeTestRun" action.
// TestRunnerManager.GetTestRunner(); =>
this.testRunnerManager = this.testRunManType.InvokeMethod <ITestRunnerManager>("GetTestRunnerManager", testAssembly, null);
this.testRunnerRegistry = this.testRunnerManager.GetMemberValue <Dictionary <int, ITestRunner> >("testRunnerRegistry");
this.syncRoot = this.testRunnerManager.GetMemberValue <object>("syncRoot");
#region (ITestRunnerManager) this.testRunnerManager => CreateTestRunner()
// aTestRunnerManager => GetTestRunner(int threadId) =>
ITestRunner testRunner;
int threadId = Thread.CurrentThread.ManagedThreadId;
if (!this.testRunnerRegistry.TryGetValue(threadId, out testRunner))
{
object obj = this.syncRoot;
bool lockTaken = false;
try
{
Monitor.Enter(obj, ref lockTaken);
if (!this.testRunnerRegistry.TryGetValue(threadId, out testRunner))
{
// ITestRunnerManager => CreateTestRunner()
#region this.testRunnerManager => CreateTestRunner
/*
* public virtual ITestRunner CreateTestRunner(int threadId)
* {
* var testRunner = CreateTestRunnerInstance();
* testRunner.InitializeTestRunner(threadId);
*
* lock (this)
* {
* if (!isTestRunInitialized)
* {
* InitializeBindingRegistry(testRunner);
* isTestRunInitialized = true;
* }
* }
*
* return testRunner;
* }
*/
testRunner = this.testRunnerManager.InvokeMethod <ITestRunner>("CreateTestRunnerInstance");
testRunner.InitializeTestRunner(threadId);
lock (this.testRunnerManager)
{
if (!this.testRunnerManager.GetMemberValue <bool>("isTestRunInitialized"))
{
#region this.testRunnerManager.InitializeBindingRegistry(testRunner);
/*
* protected virtual void InitializeBindingRegistry(ITestRunner testRunner)
* {
* var bindingAssemblies = GetBindingAssemblies();
* BuildBindingRegistry(bindingAssemblies);
*
* testRunner.OnTestRunStart();
*
#if !SILVERLIGHT
* EventHandler domainUnload = delegate { OnTestRunnerEnd(); };
* AppDomain.CurrentDomain.DomainUnload += domainUnload;
* AppDomain.CurrentDomain.ProcessExit += domainUnload;
#endif
* }
*/
var bindingAssemblies = this.testRunnerManager.InvokeMethod <object>("GetBindingAssemblies");
this.testRunnerManager.InvokeMethod <object>("BuildBindingRegistry", bindingAssemblies);
EventHandler domainUnload = delegate
{
#region this.testRunnerManager.OnTestRunnerEnd();
/*
* protected virtual void OnTestRunnerEnd()
* {
* var onTestRunnerEndExecutionHost = testRunnerRegistry.Values.FirstOrDefault();
* if (onTestRunnerEndExecutionHost != null)
* onTestRunnerEndExecutionHost.OnTestRunEnd();
*
* // this will dispose this object
* globalContainer.Dispose();
* }
*/
var onTestRunnerEndExecutionHost = testRunnerRegistry.Values.FirstOrDefault();
if (onTestRunnerEndExecutionHost != null)
{
#region onTestRunnerEndExecutionHost.OnTestRunEnd();
/*
* public virtual void OnTestRunEnd()
* {
* if (testRunnerEndExecuted)
* return;
*
* testRunnerEndExecuted = true;
* FireEvents(HookType.AfterTestRun);
* } */
if (executionEngine.GetMemberValue <bool>("testRunnerEndExecuted"))
{
return;
}
executionEngine.SetFieldValue("testRunnerEndExecuted", true);
//executionEngine.InvokeMethod("FireEvents", (HookType.AfterTestRun));
#endregion
}
// this will dispose this object
this.globalContainer.Dispose();
#endregion
};
AppDomain.CurrentDomain.DomainUnload += domainUnload;
AppDomain.CurrentDomain.ProcessExit += domainUnload;
#endregion
this.testRunnerManager.SetFieldValue("isTestRunInitialized", true);
}
}
#endregion
this.testRunnerRegistry.Add(threadId, testRunner);
if (this.testRunnerManager.IsMultiThreaded)
{
typeof(FeatureContext).InvokeMethod("DisableSingletonInstance");
typeof(ScenarioContext).InvokeMethod("DisableSingletonInstance");
typeof(ScenarioStepContext).InvokeMethod("DisableSingletonInstance");
}
}
}
finally
{
if (lockTaken)
{
Monitor.Exit(obj);
}
}
}
#endregion
return((TestRunner)testRunner);
}
static TestRunnerManager()
{
Instance = new TestRunnerManager();
}
public SharedSteps(ITestRunner testRunner, ITestRunnerManager testRunnerManager)
{
this.testRunnerManager = testRunnerManager;
this.testRunner = testRunner;
}
public TraceListenerQueue(ITraceListener traceListener, ITestRunnerManager testRunnerManager)
{
_traceListener = traceListener;
_testRunnerManager = testRunnerManager;
_isThreadSafeTraceListener = traceListener is IThreadSafeTraceListener;
}
internal static void Reset()
{
if (Instance is IDisposable)
((IDisposable)Instance).Dispose();
Instance = new TestRunnerManager();
}
static TestRunnerManager()
{
Instance = new TestRunnerManager();
}
public TraceListenerQueue(ITraceListener traceListener, ITestRunnerManager testRunnerManager)
{
this.traceListener = traceListener;
this.testRunnerManager = testRunnerManager;
isThreadSafeTraceListener = traceListener is IThreadSafeTraceListener;
}
public TraceListenerQueue(ITraceListener traceListener, ITestRunnerManager testRunnerManager)
{
this.traceListener = traceListener;
this.testRunnerManager = testRunnerManager;
isThreadSafeTraceListener = traceListener is IThreadSafeTraceListener;
}
private TestLauncherResult RunWithRuntime()
{
bool wasCanceled = false;
ITestProjectManager testProjectManager = RuntimeAccessor.ServiceLocator.Resolve <ITestProjectManager>();
TestProject consolidatedTestProject = ConsolidateTestProject(testProjectManager, ref wasCanceled);
if (wasCanceled)
{
return(CreateResult(ResultCode.Canceled, testProject));
}
if (consolidatedTestProject == null)
{
return(CreateResult(ResultCode.InvalidArguments, testProject));
}
if (consolidatedTestProject.TestPackage.Files.Count == 0)
{
logger.Log(LogSeverity.Warning, "No test files to execute!");
return(CreateResult(ResultCode.NoTests, consolidatedTestProject));
}
IReportManager reportManager = RuntimeAccessor.ServiceLocator.Resolve <IReportManager>();
if (!ValidateReportFormats(reportManager, consolidatedTestProject))
{
return(CreateResult(ResultCode.InvalidArguments, consolidatedTestProject));
}
ITestRunnerManager testRunnerManager = RuntimeAccessor.ServiceLocator.Resolve <ITestRunnerManager>();
ITestRunnerFactory testRunnerFactory = testRunnerManager.GetFactory(consolidatedTestProject.TestRunnerFactoryName);
if (testRunnerFactory == null)
{
logger.Log(LogSeverity.Error, String.Format("Unrecognized test runner factory name: '{0}'.", consolidatedTestProject.TestRunnerFactoryName));
return(CreateResult(ResultCode.InvalidArguments, consolidatedTestProject));
}
ITestRunner runner = testRunnerFactory.CreateTestRunner();
var result = new TestLauncherResult(new Report {
TestPackage = new TestPackageData(TestProject.TestPackage)
});
try
{
DoRegisterExtensions(runner, consolidatedTestProject);
DoInitialize(runner, ref wasCanceled);
if (!wasCanceled)
{
result = RunWithInitializedRunner(runner, consolidatedTestProject, reportManager);
}
}
finally
{
DoDispose(runner, ref wasCanceled);
}
if (wasCanceled)
{
result.SetResultCode(ResultCode.Canceled);
}
return(result);
}
