static partial void RegisterCommands(IObjectContainer container) { var serviceProvider = container.Resolve<IServiceProvider>(); container.RegisterInstanceAs<MenuCommandHandler>(new DelegateMenuCommandHandler(serviceProvider, container.Resolve<DTE>(), (_1, _2) => System.Windows.MessageBox.Show("generate skeleton")), SpecFlowCmdSet.GenerateStepDefinitionSkeleton.ToString()); container.RegisterTypeAs<RunScenariosCommand, MenuCommandHandler>(SpecFlowCmdSet.RunScenarios.ToString()); container.RegisterTypeAs<DebugScenariosCommand, MenuCommandHandler>(SpecFlowCmdSet.DebugScenarios.ToString()); container.RegisterTypeAs<ReGenerateAllCommand, MenuCommandHandler>(SpecFlowCmdSet.ReGenerateAll.ToString()); }
public override void OnData(IObjectContainer container,AppSocketSession session, AppSocketData data) { try { container.Resolve<IRawDataService>().Log(session, Encoding.UTF8.GetString(data.RawData)); } catch (Exception ex) { container.Resolve<ILogger>().Error("记录原始数据错误", ex); } }
public override void OnData(IObjectContainer container,AppSocketSession session, AppSocketData data) { try { container.Resolve<IRawDataService>().Log(session, ByteHelper.ConvertBytesToStringByHex(data.RawData, ",")); } catch (Exception ex) { container.Resolve<ILogger>().Error("记录原始数据错误", ex); } }
public virtual void RegisterDefaults(IObjectContainer container) { var serviceProvider = container.Resolve<IServiceProvider>(); RegisterVsDependencies(container, serviceProvider); container.RegisterTypeAs<InstallServices, InstallServices>(); container.RegisterTypeAs<VsBrowserGuidanceNotificationService, IGuidanceNotificationService>(); container.RegisterTypeAs<WindowsFileAssociationDetector, IFileAssociationDetector>(); container.RegisterTypeAs<RegistryStatusAccessor, IStatusAccessor>(); container.RegisterTypeAs<IntegrationOptionsProvider, IIntegrationOptionsProvider>(); container.RegisterInstanceAs<IIdeTracer>(VsxHelper.ResolveMefDependency<IVisualStudioTracer>(serviceProvider)); container.RegisterInstanceAs(VsxHelper.ResolveMefDependency<IProjectScopeFactory>(serviceProvider)); container.RegisterTypeAs<TestRunnerEngine, ITestRunnerEngine>(); container.RegisterTypeAs<TestRunnerGatewayProvider, ITestRunnerGatewayProvider>(); container.RegisterTypeAs<MsTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.VisualStudio2010MsTest.ToString()); container.RegisterTypeAs<ReSharper5TestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.ReSharper5.ToString()); container.RegisterTypeAs<ReSharper6TestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.ReSharper.ToString()); container.RegisterTypeAs<SpecRunTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.SpecRun.ToString()); container.RegisterTypeAs<VS2012RunnerGateway, ITestRunnerGateway>(TestRunnerTool.VisualStudio2012.ToString()); container.RegisterTypeAs<AutoTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.Auto.ToString()); container.RegisterTypeAs<StepDefinitionSkeletonProvider, IStepDefinitionSkeletonProvider>(); container.RegisterTypeAs<DefaultSkeletonTemplateProvider, ISkeletonTemplateProvider>(); container.RegisterTypeAs<StepTextAnalyzer, IStepTextAnalyzer>(); RegisterCommands(container); }
static internal TestRunner CreateTestRunner(out IObjectContainer container, Action<IObjectContainer> registerMocks = null) { container = TestRunContainerBuilder.CreateContainer(); if (registerMocks != null) registerMocks(container); return (TestRunner)container.Resolve<ITestRunner>(); }
public override void OnData(IObjectContainer container,AppSocketSession session, AppSocketData data) { try { var log = string.Empty; if (data.RawData[0] == 0x2a) { log = Encoding.ASCII.GetString(data.RawData); } else { log = ByteHelper.ConvertBytesToStringByHex(data.RawData, ","); } container.Resolve<IRawDataService>().Log(session, log); } catch (Exception ex) { container.Resolve<ILogger>().Error("记录原始数据错误", ex); } }
private static IMessageBus BuildMessageBus(AbstractConfiguration cfg) { ISubscriptionService subscriptionService = MessageBusConfigurationExtensions.GetSubscriptionService(cfg); IMessageSink messageSink = MessageBusConfigurationExtensions.GetMessageSink(cfg); IObjectContainer container = ObjectContainerConfigurationExtensions.GetObjectContainer(cfg); IRouteManager routeManager = container.Resolve <IRouteManager>(); Xyperico.Agres.MessageBus.Implementation.MessageBus bus = new Agres.MessageBus.Implementation.MessageBus(subscriptionService, routeManager, messageSink); container.RegisterInstance <IMessageBus>(bus); return(bus); }
private ITaskItem[] GenerateCodeBehindFilesForProject(IObjectContainer container, List <string> featureFiles) { var generator = container.Resolve <IFeatureFileCodeBehindGenerator>(); var generatedFiles = generator.GenerateFilesForProject( featureFiles, ProjectFolder, OutputPath); return(generatedFiles.Select(file => new TaskItem { ItemSpec = file }).ToArray()); }
public void GivenTheFollowingRoatpProvidersAreAvailable(Table table) { var stubrepo = _objectContainer.Resolve <StubProviderRepository>("StubRepo"); stubrepo.roatpProviderDocuments.AddRange(ToRoatpProviders(table)); var availableroatpdata = stubrepo.roatpProviderDocuments; }
public void MakeScreenshot(string name) { var path = _container.Resolve <Artifacts>().GetPath(name + ".png"); var screenshot = WebDriver.TakeScreenshot(); screenshot.SaveAsFile(path); }
private void RegisterSpecflowDependencies(IObjectContainer objectContainer, IWindsorContainer windsorContainer) { windsorContainer.Register(Component.For <IObjectContainer>() .UsingFactoryMethod(() => objectContainer) .LifestyleTransient() .OnlyNewServices()); windsorContainer.Register(Component.For <ScenarioContext>() .UsingFactoryMethod(() => objectContainer.Resolve <ScenarioContext>()) .LifestyleTransient() .OnlyNewServices()); windsorContainer.Register(Component.For <FeatureContext>() .UsingFactoryMethod(() => objectContainer.Resolve <FeatureContext>()) .LifestyleTransient() .OnlyNewServices()); windsorContainer.Register(Component.For <TestThreadContext>() .UsingFactoryMethod(() => objectContainer.Resolve <TestThreadContext>()) .LifestyleTransient() .OnlyNewServices()); }
public PropertyBasedTestRunner(ITestExecutionEngine executionEngine, IObjectContainer container) { this.normalExecutionEngine = executionEngine; var nullContainer = new ObjectContainer(container); nullContainer.RegisterInstanceAs((IBindingInvoker) new NullBindingInvoker()); nullContainer.RegisterTypeAs <TestExecutionEngine, ITestExecutionEngine>(); this.nullExecutionEngine = nullContainer.Resolve <ITestExecutionEngine>(); //TODO: check with newer SpecFlow if this is still necessary container.RegisterTypeAs <PropertyBasedTestContext, PropertyBasedTestContext>(); propertyBasedTestContext = container.Resolve <PropertyBasedTestContext>(); }
public static IObjectContainer AddAutoMapper(this IObjectContainer builder, params Assembly[] assemblies) { if (builder is null) { return(null); } var configurationProvider = new MapperConfiguration(config => config.AddMaps(assemblies)); builder.RegisterInstanceAs <IConfigurationProvider>(configurationProvider); builder.RegisterInstanceAs <IMapper>(new Mapper(builder.Resolve <IConfigurationProvider>())); return(builder); }
public void AfterScenario() { //TODO: implement logic that has to run after executing each scenario Console.WriteLine("Calling after scenario"); var featureTitle = FeatureContext.Current.FeatureInfo.Title; var scenarioTitle = ScenarioContext.Current.ScenarioInfo.Title; var scenarioTag = ScenarioContext.Current.ScenarioInfo.Tags; Console.WriteLine($"FeatureTitle: {featureTitle} and ScenarioTitle = {scenarioTitle} with scenarioTag {scenarioTag}"); _driver = _objectContainer.Resolve <IWebDriver>(); _driver.Close(); _driver.Dispose(); _driver.Quit(); }
public ITestRunnerGateway GetTestRunnerGateway() { TestRunnerTool testRunnerTool = integrationOptionsProvider.GetOptions().TestRunnerTool; try { return(container.Resolve <ITestRunnerGateway>(testRunnerTool.ToString())); } catch (Exception ex) { tracer.Trace("Unable to resolve test runner gateway: " + ex, GetType().Name); return(null); } }
private void SetupCallAction(CodeStatementCollection statements) { //action(); var callActionStatement = new CodeDelegateInvokeExpression( new CodeVariableReferenceExpression(NamingHelper.TestActionParameterName)); JsonConfig config = _container.Resolve <JsonConfig>(); if (string.Equals(config.UnitTestProvider, "nunit", StringComparison.InvariantCultureIgnoreCase)) { /* * var testExecutionContext = new TestExecutionContext.IsolatedContext(); * try * { * action(); * } * finally * { * testExecutionContext.Dispose(); * } */ statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(NunitTestExecutionContextClassName), NamingHelper.TestExecutionContextVariableName, new CodeObjectCreateExpression(new CodeTypeReference(NunitTestExecutionContextClassName)))); var tryFinallyStatement = new CodeTryCatchFinallyStatement(); tryFinallyStatement.TryStatements.Add(callActionStatement); tryFinallyStatement.FinallyStatements.Add(new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(NamingHelper.TestExecutionContextVariableName), nameof(IDisposable.Dispose))); statements.Add(tryFinallyStatement); } else { statements.Add(callActionStatement); } }
public void BeforeScenario(ScenarioContext scenarioContext) { Console.WriteLine("BeforeScenario called"); DriverFactory driverFactory = _objectContainer.Resolve <DriverFactory>(); _driver = driverFactory.CreateDriver(); _objectContainer.RegisterInstanceAs(_driver); string fileName = scenarioContext.ScenarioInfo.Title.Replace(" ", string.Empty); fileName += DateTime.UtcNow.ToString("-yyyyMMdd_Hmm"); string outputDirectoryName = ApplicationSettings.TestsVideoDirectory; }
public static void loadReporter(FeatureContext context, IObjectContainer container) { var config = container.Resolve <IConfiguration>(); if (config["appSettings:Reporter"] == "extent") { container.RegisterInstanceAs <IReportHelper>(new ExtentReportHelper()); ExtentReportHelper.startReporter(context); } else { container.RegisterInstanceAs <IReportHelper>(new XmlReportHelper()); XmlReportHelper.startReporter(context); } }
/// <summary> /// Initialization of the package; this method is called right after the package is sited, so this is the place /// where you can put all the initilaization code that rely on services provided by VisualStudio. /// </summary> protected override void Initialize() { Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString())); base.Initialize(); Container = VsContainerBuilder.CreateContainer(this); OleMenuCommandService menuCommandService = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if (menuCommandService != null) { foreach (var menuCommandHandler in Container.Resolve<IDictionary<SpecFlowCmdSet, MenuCommandHandler>>()) { menuCommandHandler.Value.RegisterTo(menuCommandService, menuCommandHandler.Key); } } }
public void Build() { _objectContainer.RegisterTypeAs <ScenarioExecutionConsumer, IScenarioExecutionConsumer>(); _objectContainer.RegisterTypeAs <DriverService, IDriverService>(); _objectContainer.RegisterTypeAs <ElementSelectionService, IElementSelectionService>(); _objectContainer.RegisterTypeAs <AutomationIdProvider, IAutomationIdProvider>(); _objectContainer.RegisterTypeAs <ScopeMarkupStorageContainer, IScopeMarkupStorageContainer>(); _objectContainer.RegisterTypeAs <ScopeMarkupMapper, IScopeMarkupMapper>(); _objectContainer.RegisterTypeAs <UriToPageScopeMapper, IUriToPageScopeMapper>(); _objectContainer.RegisterTypeAs <ScopeContextManager, IScopeContextManager>(); _objectContainer.RegisterTypeAs <ScopeContextRuntime, IScopeContextRuntime>(); var builder = _objectContainer.Resolve <IUserInterfaceBuilder>(); builder.Build(); }
public void CaptureScreenshotsOnError() { if (scenarioContext?.TestError == null) { return; } try { var session = objectContainer.Resolve <ISession>(); session.CaptureScreenShot(Path.Combine(Path.GetTempPath(), scenarioContext.ScenarioInfo.Title + ".png")); } catch (Exception e) { Console.WriteLine($"Could not capture screenshot: '{e.Message}'"); } }
/// <summary> /// Initialization of the package; this method is called right after the package is sited, so this is the place /// where you can put all the initilaization code that rely on services provided by VisualStudio. /// </summary> protected override void Initialize() { Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString())); base.Initialize(); Container = VsContainerBuilder.CreateContainer(this); OleMenuCommandService menuCommandService = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if (menuCommandService != null) { foreach (var menuCommandHandler in Container.Resolve <IDictionary <SpecFlowCmdSet, MenuCommandHandler> >()) { menuCommandHandler.Value.RegisterTo(menuCommandService, menuCommandHandler.Key); } } }
private void TryLog(Exception ex) { try { IObjectContainer objectContainer = ObjectContainerFactory.GetObjectContainer(); if (!objectContainer.IsRegistered(typeof(ILogger))) { objectContainer.RegisterType <ILogger, WcfLogger>(new object[0]); } objectContainer.Resolve <ILogger>().Error(ex, null); } catch (Exception exception) { Debug.WriteLine("WCF log exception error:"); Debug.WriteLine(exception.Message); } }
public void AfterScenario(IObjectContainer container, ScenarioContext context, ScenarioInfo info) { Console.WriteLine($"### AfterScenario: {info.Title}"); if (context.TestError != null) { Console.WriteLine($"### Scenario Error: {context.TestError.Message}"); var screenshotName = new StringBuilder(info.Title); foreach (var invalidFileNameChar in Path.GetInvalidFileNameChars()) { screenshotName.Replace(invalidFileNameChar, ' '); } container.Resolve <AnyPage>().MakeScreenshot(screenshotName.ToString()); } }
public void TearDown() { IWebDriver driver = container.Resolve <IWebDriver>(); // Screenshot string img = SaveScreenShotClass.SaveScreenshot(Driver.driver, "Report"); // test.Log(LogStatus.Info, "Snapshot below: " + test.AddScreenCapture(img)); //Close the browser Close(); // end test. (Reports) // CommonMethods.Extent.EndTest(test); // calling Flush writes everything to the log file (Reports) // CommonMethods.Extent.Flush(); }
/// <summary> /// Get the web driver initialiser for the configured browser type. /// </summary> /// <param name="arg">The object container.</param> /// <returns>The web driver intialiser.</returns> private static IWebDriverInitialiser GetWebDriverInitialiser(IObjectContainer arg) { var testConfiguration = arg.Resolve <ITestConfiguration>(); switch (testConfiguration.BrowserType) { case BrowserType.Chrome: return(new ChromeWebDriverInitialiser()); case BrowserType.Edge: return(new EdgeWebDriverInitialiser()); case BrowserType.InternetExplorer: return(new InternetExporerWebDriverInitialiser()); case BrowserType.Firefox: return(new FirefoxWebDriverInitialiser()); default: throw new Exception($"Browser type {testConfiguration.BrowserType} is not configured."); } }
public void Initialize(IObjectContainer container, IEnumerable <Type> types) { types.Where(type => type.IsClass && !type.IsAbstract && typeof(IResult).IsAssignableFrom(type)) .ForEach(resultType => { var handler = container.Resolve(typeof(IEnvelopedMessageHandler <>).MakeGenericType(resultType)); if (handler == null) { var errorMessage = string.Format("not found the handler of this type('{0}') with IEnvelopedMessageHandler<>.", resultType.FullName); LogManager.Default.Fatal(errorMessage); throw new SystemException(errorMessage); } _resultHandlers[resultType] = handler; }); }
public void WhenASubmissionEventHasRaisedWithEmpRefAAAndNINOQQCAndULN(string apprenticeshipId, string nino, string uln, string ukprn) { _uln = long.Parse(uln); var providereventsApiMessageHandlers = _objectContainer.Resolve <ProviderEventsApiMessageHandler>(); var submissionEvents = _objectCreator.Create <SubmissionEvent>(x => { x.ActualStartDate = new DateTime(2017, 12, 14); x.ApprenticeshipId = long.Parse(apprenticeshipId); x.Ukprn = long.Parse(ukprn); x.NiNumber = nino; x.Id = 1; x.Uln = _uln; }); providereventsApiMessageHandlers.SetupGetSubmissionEvents(1, new PageOfResults <SubmissionEvent> { Items = new[] { submissionEvents }, PageNumber = 1, TotalNumberOfPages = 1 }); }
public virtual void RegisterDefaults(IObjectContainer container) { var serviceProvider = container.Resolve<IServiceProvider>(); RegisterVsDependencies(container, serviceProvider); container.RegisterTypeAs<IntegrationOptionsProvider, IIntegrationOptionsProvider>(); container.RegisterInstanceAs<IIdeTracer>(VsxHelper.ResolveMefDependency<IVisualStudioTracer>(serviceProvider)); container.RegisterInstanceAs(VsxHelper.ResolveMefDependency<IProjectScopeFactory>(serviceProvider)); container.RegisterTypeAs<TestRunnerEngine, ITestRunnerEngine>(); container.RegisterTypeAs<TestRunnerGatewayProvider, ITestRunnerGatewayProvider>(); container.RegisterTypeAs<MsTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.MsTest.ToString()); container.RegisterTypeAs<ReSharperTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.ReSharper.ToString()); container.RegisterTypeAs<SpecRunTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.SpecRun.ToString()); container.RegisterTypeAs<AutoTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.Auto.ToString()); RegisterCommands(container); }
private static ITestRunner CreateTestRunner(Assembly testAssembly) { var testRunContainerBuilderType = typeof(ITestRunner).Assembly .GetType("TechTalk.SpecFlow.Infrastructure.TestRunContainerBuilder", true); var testRunContainerBuilder = testRunContainerBuilderType.ReflectionCreateInstance <object>( new[] { typeof(IDefaultDependencyProvider) }, new object[] { null }); IObjectContainer container = testRunContainerBuilder.ReflectionCallMethod <IObjectContainer>( "CreateContainer", new[] { typeof(IRuntimeConfigurationProvider) }, new object[] { null }); // reset IBindingInvoker to avoid invoking hooks (Issue #27) container.RegisterTypeAs <NoInvokeDependencyProvider.NullBindingInvoker, IBindingInvoker>(); var testRunnerManager = container.Resolve <ITestRunnerManager>(); testRunnerManager.Initialize(testAssembly); return(testRunnerManager.GetTestRunner(0)); }
protected override object DoGetInstance(Type serviceType, string key) { if (!string.IsNullOrWhiteSpace(key)) { throw new NotImplementedException("DoGetInstance when key has a value has not been implemented."); } try { var value = _objectContainer.Resolve(serviceType); return(value); } catch (Exception exception) { throw new Exception(string.Format("{0} has not been registered with IObjectContainer. See {1}.BeforeScenario().", serviceType, typeof(SetupSteps)), exception); } }
/// <summary> /// No more configuration needed for message bus - now configure something else or start the bus. /// </summary> /// <param name="cfg"></param> /// <returns></returns> public static BaseConfiguration Done(this MessageBusConfiguration cfg) { IObjectContainer container = ObjectContainerConfigurationExtensions.GetObjectContainer(cfg); IDocumentStoreFactory subscriptionStoreFactory = GetSubscriptionStore(cfg); if (!container.HasComponent(typeof(IRouteManager))) { container.AddComponent <IRouteManager, RouteManager>(); } IRouteManager routeManager = container.Resolve <IRouteManager>(); ISubscriptionService subscriptionService = new SubscriptionService(subscriptionStoreFactory, routeManager); cfg.Set(SubscriptionService_SettingsKey, subscriptionService); container.RegisterInstance <ISubscriptionService>(subscriptionService); return(new BaseConfiguration(cfg)); }
public void TakeScreenshot(IWebDriver driver, IObjectContainer objectContainer) { var screenshot = ((ITakesScreenshot)driver).GetScreenshot(); var screenshotTitle = DateTime.Now.ToString("yyyy-MM-dd-HH_mm_ss"); var scenarioInfo = objectContainer.Resolve <ScenarioInfo>(); var scenarioTitle = scenarioInfo.Title; string screenshotfilename = scenarioTitle + "_" + screenshotTitle + ".jpg"; string folder = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData); string specificFolder = Path.Combine(folder, "Temp", "AutomatedTests", "Screenshots"); if (!Directory.Exists(specificFolder)) { Directory.CreateDirectory(specificFolder); } string filePath = Path.Combine(specificFolder, screenshotfilename); screenshot.SaveAsFile(filePath, OpenQA.Selenium.ScreenshotImageFormat.Jpeg); }
public virtual void RegisterDefaults(IObjectContainer container) { var serviceProvider = container.Resolve <IServiceProvider>(); RegisterVsDependencies(container, serviceProvider); container.RegisterTypeAs <IntegrationOptionsProvider, IIntegrationOptionsProvider>(); container.RegisterInstanceAs <IIdeTracer>(VsxHelper.ResolveMefDependency <IVisualStudioTracer>(serviceProvider)); container.RegisterInstanceAs(VsxHelper.ResolveMefDependency <IProjectScopeFactory>(serviceProvider)); container.RegisterTypeAs <TestRunnerEngine, ITestRunnerEngine>(); container.RegisterTypeAs <TestRunnerGatewayProvider, ITestRunnerGatewayProvider>(); container.RegisterTypeAs <MsTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.MsTest.ToString()); container.RegisterTypeAs <ReSharper5TestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.ReSharper5.ToString()); container.RegisterTypeAs <ReSharper6TestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.ReSharper.ToString()); container.RegisterTypeAs <SpecRunTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.SpecRun.ToString()); container.RegisterTypeAs <AutoTestRunnerGateway, ITestRunnerGateway>(TestRunnerTool.Auto.ToString()); RegisterCommands(container); }
/// <summary> /// Initializes a new instance of the <see cref="BeforeReleaseCallCommand"/> class. /// </summary> /// <param name="container">The container.</param> public MarkDoneCommand(IObjectContainer container) { this.container = container; // Initialize the trace system this.log = container.Resolve <ILogger>(); // Create a child trace section this.log = log.CreateChildLogger("MarkDoneLog"); var contextDictionary = Context as IDictionary <string, object>; object caseObject; if (contextDictionary != null && contextDictionary.TryGetValue("Case", out caseObject)) { var theCase = caseObject as ICase; _caseIdentifier = theCase; } }
/// <summary> /// 获取格式化器 /// </summary> /// <param name="data"></param> /// <returns></returns> //public async static Task<FormatterBase> GetFormatterAsync(String data) public static FormatterBase GetFormatter(string data) { // var protocal = await GetDataProtocalTypeAsync(data); //var protocal = GetDataProtocalType(data); const DataProtocalType protocal = DataProtocalType.Json; //switch (protocal) //{ // case DataProtocalType.Json: // formatter = new JsonFormatter(); // break; // case DataProtocalType.Xml: // formatter = new XmlFormatter(); // break; // default: // formatter = new NotSupportFormatter(); // break; //} var formatter = Container.Resolve <FormatterBase>(protocal.ToString()); return(formatter); }
public CiscoVoiceView(ICiscoVoiceModel ciscoVoiceModel, IObjectContainer container) { Model = ciscoVoiceModel; Model.FinAgent = FinesseEventListener.Instance.FinAgent; this.container = container; var interactionManager = container.Resolve <IInteractionManager>(); if (interactionManager != null) { interactionManager.InteractionEvent += InteractionManager_InteractionEvent; } InitializeComponent(); Width = Double.NaN; Height = Double.NaN; MinSize = new MSize() { Width = 600, Height = 400.0 }; }
public virtual void RegisterDefaults(IObjectContainer container) { var serviceProvider = container.Resolve <IServiceProvider>(); RegisterVsDependencies(container, serviceProvider); container.RegisterTypeAs <InstallServices, InstallServices>(); container.RegisterTypeAs <InstallServicesHelper, InstallServicesHelper>(); container.RegisterTypeAs <VsBrowserGuidanceNotificationService, IGuidanceNotificationService>(); container.RegisterTypeAs <WindowsFileAssociationDetector, IFileAssociationDetector>(); container.RegisterTypeAs <RegistryStatusAccessor, IStatusAccessor>(); container.RegisterTypeAs <WindowsRegistry, IWindowsRegistry>(); container.RegisterTypeAs <FileService, IFileService>(); container.RegisterTypeAs <DirectoryService, IDirectoryService>(); container.RegisterInstanceAs <IIdeTracer>(VsxHelper.ResolveMefDependency <IVisualStudioTracer>(serviceProvider)); container.RegisterInstanceAs(VsxHelper.ResolveMefDependency <IProjectScopeFactory>(serviceProvider)); container.RegisterTypeAs <StepDefinitionSkeletonProvider, IStepDefinitionSkeletonProvider>(); container.RegisterTypeAs <DefaultSkeletonTemplateProvider, ISkeletonTemplateProvider>(); container.RegisterTypeAs <StepTextAnalyzer, IStepTextAnalyzer>(); container.RegisterTypeAs <TelemetryClientWrapper, TelemetryClientWrapper>(); container.RegisterTypeAs <AppInsightsEventConverter, IAppInsightsEventConverter>(); container.RegisterTypeAs <AppInsightsAnalyticsTransmitterSink, IAnalyticsTransmitterSink>(); container.RegisterTypeAs <VisualStudioProjectTargetFrameworksProvider, IProjectTargetFrameworksProvider>(); container.RegisterTypeAs <VisualStudioIdeInformationStore, IIdeInformationStore>(); container.RegisterTypeAs <AnalyticsTransmitter, IAnalyticsTransmitter>(); container.RegisterTypeAs <EnableAnalyticsChecker, IEnableAnalyticsChecker>(); container.RegisterTypeAs <FileUserIdStore, IUserUniqueIdStore>(); container.RegisterTypeAs <EnvironmentSpecFlowTelemetryChecker, IEnvironmentSpecFlowTelemetryChecker>(); container.RegisterTypeAs <CurrentExtensionVersionProvider, ICurrentExtensionVersionProvider>(); container.RegisterTypeAs <DevBuildChecker, IDevBuildChecker>(); RegisterCommands(container); }
public void Setup() { container = GeneratorContainerBuilder.CreateContainer(new SpecFlowConfigurationHolder(), new ProjectSettings()); container.RegisterInstanceAs<IUnitTestGeneratorProvider>(container.Resolve<XUnitTestGeneratorProvider>()); }
public FeatureGeneratorRegistry(IObjectContainer objectContainer) { providers = objectContainer.Resolve<IDictionary<string, IFeatureGeneratorProvider>>().OrderBy(item => item.Value.Priority).ToList(); }
/// <summary> /// 创建一个可用于缓存的拦截器 /// </summary> public override IInterceptor CreateInterceptor(IObjectContainer container) { var cacheProvider = container.Resolve<ICacheProvider>(); return new CachingInterceptor(this, cacheProvider); }
public BindingFactory(IObjectContainer container) { this.runtimeConfiguration = container.Resolve<RuntimeConfiguration>(); this.errorProvider = container.Resolve<IErrorProvider>(); }
public PostSteps(IObjectContainer objectContainer) { _lazyOrchardClientForMarkus = new Lazy<IOrchardClient>(() =>objectContainer.Resolve<IOrchardClient>(ExampleUser.MarkusMachado.Username)); _lazyOrchardClientForVasundhara = new Lazy<IOrchardClient>(() => objectContainer.Resolve<IOrchardClient>(ExampleUser.VasundharaAraya.Username)); }
public ITestRunnerGateway CreateTestRunner(IObjectContainer container) { return container.Resolve<ITestRunnerGateway>(tool.ToString()); }
public virtual IObjectContainer CreateScenarioContainer(IObjectContainer testThreadContainer, ScenarioInfo scenarioInfo) { if (testThreadContainer == null) throw new ArgumentNullException(nameof(testThreadContainer)); var scenarioContainer = new ObjectContainer(testThreadContainer); scenarioContainer.RegisterInstanceAs(scenarioInfo); var contextManager = testThreadContainer.Resolve<IContextManager>(); var featureContext = contextManager.FeatureContext; if (featureContext != null) scenarioContainer.RegisterInstanceAs(featureContext); scenarioContainer.ObjectCreated += obj => { var containerDependentObject = obj as IContainerDependentObject; if (containerDependentObject != null) containerDependentObject.SetObjectContainer(scenarioContainer); }; var runtimePluginEvents = testThreadContainer.Resolve<RuntimePluginEvents>(); runtimePluginEvents.RaiseCustomizeScenarioDependencies(scenarioContainer); return scenarioContainer; }
public void Invoke(IObjectContainer dependencyResolver, object message) { object handlerInstance = dependencyResolver.Resolve(Method.DeclaringType); Method.Invoke(handlerInstance, new object[] { message }); }
public override void OnStoped(IObjectContainer container) { container.Resolve<IQueueService>().Stop(); container.Resolve<IRawDataService>().Stop(); container.Resolve<IInstructionService>().Stop(); }
internal static TestRunner CreateTestRunner(out IObjectContainer createThreadContainer, Action<IObjectContainer> registerTestThreadMocks = null, Action<IObjectContainer> registerGlobalMocks = null) { createThreadContainer = CreateDefaultTestThreadContainer(registerTestThreadMocks: registerTestThreadMocks, registerGlobalMocks: registerGlobalMocks); return (TestRunner)createThreadContainer.Resolve<ITestRunner>(); }
public object ResolveBindingInstance(Type bindingType, IObjectContainer scenarioContainer) { return scenarioContainer.Resolve(bindingType); }
public virtual IObjectContainer CreateTestThreadContainer(IObjectContainer globalContainer) { var testThreadContainer = new ObjectContainer(globalContainer); defaultDependencyProvider.RegisterTestThreadContainerDefaults(testThreadContainer); var runtimePluginEvents = globalContainer.Resolve<RuntimePluginEvents>(); runtimePluginEvents.RaiseCustomizeTestThreadDependencies(testThreadContainer); testThreadContainer.Resolve<IBindingInstanceResolver>(); return testThreadContainer; }