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(); }
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); }