public void TestCommandserviceC() { var container = new DependencyInjector(new ServiceConfiguration(), new ServiceConfigurationC()); var service = container.GetObject<ISomeDomainCmdService>("C"); Assert.IsNotNull(service); Assert.IsInstanceOf<SomeDomainCmdServiceC>(service); }
public void TestAmbiguesObjectResolvement() { var container = new DependencyInjector(new ServiceConfiguration(), new ServiceConfigurationC()); var composit = container.GetObject<Composit>(); Assert.IsNotNull(composit); Assert.IsInstanceOf<SomeDomainCmdServiceD>(composit.Service); }
public void TestContainsPrototypeWithObjectArg() { var container = new DependencyInjector(new ServiceConfiguration(), new MoreConfig()); container.ExpandConfiguration(new ComplexConfig(), new ServiceConfigurationC()).Reconfigure(); bool b = container.ContainsObject(typeof(Prototype)); Assert.IsTrue(b); }
public void TestConfigurationExpansion() { var container = new DependencyInjector(new ServiceConfiguration(), new MoreConfig()); Assert.IsNotNull(container); Assert.IsTrue(container.ContainsObject<ISomeDomainCmdService>()); Assert.IsTrue(container.ContainsObject<ICommandManager>()); Assert.IsTrue(container.ContainsObject("SomeDomainCmdServiceB")); container.ExpandConfiguration(new ComplexConfig()); Assert.IsTrue(container.ContainsObject<IAggregate>()); }
private static void Prepare() { Injector = new DependencyInjector(new string[] { IoHelpers.GetStartupPath(), IoHelpers.GetActionPath() }); var templatePath = Path.Combine(IoHelpers.GetStartupPath(), "Templates"); if (!Directory.Exists(templatePath)) Directory.CreateDirectory(templatePath); }
public void TestDisposeAndReConfiguration() { var container = new DependencyInjector(new ServiceConfiguration(), new MoreConfig()); Assert.IsNotNull(container); Assert.IsTrue(container.ContainsObject<ISomeDomainCmdService>()); Assert.IsTrue(container.ContainsObject<ICommandManager>()); Assert.IsTrue(container.ContainsObject("SomeDomainCmdServiceB")); container.ExpandConfiguration(new ComplexConfig()); Assert.IsTrue(container.ContainsObject<IAggregate>()); container.Reconfigure(); Assert.IsTrue(container.ContainsObject<ISomeDomainCmdService>()); Assert.IsTrue(container.ContainsObject<ICommandManager>()); Assert.IsTrue(container.ContainsObject("SomeDomainCmdServiceB")); Assert.IsTrue(container.ContainsObject<IAggregate>()); IAggregate aggregate = container.GetObject<IAggregate>(); Assert.IsNotNull(aggregate); var b = container.GetObject("SomeDomainCmdServiceB"); Assert.IsNotNull(b); container.Dispose(); Assert.Throws<DependencyInjectorGetObjectException>(() => container.GetObject("SomeDomainCmdServiceB")); container = new DependencyInjector(new ServiceConfiguration(), new MoreConfig()); Assert.IsNotNull(container); Assert.IsTrue(container.ContainsObject<ISomeDomainCmdService>()); Assert.IsTrue(container.ContainsObject<ICommandManager>()); Assert.IsTrue(container.ContainsObject("SomeDomainCmdServiceB")); container.ExpandConfiguration(new ComplexConfig()); Assert.IsTrue(container.ContainsObject<IAggregate>()); container.Reconfigure(); Assert.IsTrue(container.ContainsObject<ISomeDomainCmdService>()); Assert.IsTrue(container.ContainsObject<ICommandManager>()); Assert.IsTrue(container.ContainsObject("SomeDomainCmdServiceB")); Assert.IsTrue(container.ContainsObject<IAggregate>()); aggregate = container.GetObject<IAggregate>(); Assert.IsNotNull(aggregate); b = container.GetObject("SomeDomainCmdServiceB"); Assert.IsNotNull(b); }
public static void Init() { DependencyInjector.Register <IStorageBL, StorageBL>(); DependencyInjector.Register <IMessageQueueHandler <Game>, MessageQueueHandler <Game> >(); DependencyInjector.Register <IStorageRepo, DbRepo>(); }
public void TestGetObjectsInheritingFromPrototypeSuperClassFromContainer() { var container = new DependencyInjector(new ServiceConfiguration(), new MoreConfig()); container.ExpandConfiguration(new ComplexConfig()); container.Reconfigure(); List<Prototype> prototypes = container.GetAllObjectsInheriting<Prototype>(); Assert.AreEqual(1, prototypes.Count); }
public IHashTestHost CreateInstance(TestContext context) { var provider = DependencyInjector.Get <ICryptoProvider> (); return(provider.GetHashTestHost(ProviderType)); }
public override void Initialize() { base.Initialize(); DependencyInjector.RegisterDependency <IBuiltinTestServer> (() => new BuiltinTestServer()); }
private void fun(DependencyInjector pdi, Constructed ca, Constructed cb, Constructed cc) { }
public DiInstanceProvider(DependencyInjector container, Type serviceType) { this.serviceType = serviceType; this.container = container; }
public static void ConfigureDependencyInjector(this IServiceCollection services) { DependencyInjector.Configure(services); }
public void TestSimpleOrderingOfObjectsInMetaDataMap() { var container = new DependencyInjector(new ServiceConfiguration()); Assert.IsNotNull(container); Assert.IsTrue(container.ContainsObject<ISomeDomainCmdService>()); Assert.IsTrue(container.ContainsObject<ICommandManager>()); }
public DiServiceBehavior(DependencyInjector container) { this.container = container; }
public DiServiceHostFactory(DependencyInjector container) : base(container) { }
public void TestOrderingOfAggregatedObjectsInMetaDataMap() { var container = new DependencyInjector(new ServiceConfiguration(), new MoreConfig(), new ComplexConfig()); Assert.IsNotNull(container); Assert.IsTrue(container.ContainsObject<ISomeDomainCmdService>()); Assert.IsTrue(container.ContainsObject<ICommandManager>()); Assert.IsTrue(container.ContainsObject("SomeDomainCmdServiceB")); Assert.IsTrue(container.ContainsObject<IAggregate>()); }
public void TestGetPrototypeFromContainerObjArgsWithId() { var container = new DependencyInjector(new ServiceConfiguration(), new MoreConfig()); container.ExpandConfiguration(new ComplexConfig(), new ServiceConfigurationC()).Reconfigure(); Prototype prototype = (Prototype)container.GetObject(typeof(Prototype).FullName); Assert.IsNotNull(prototype); }
public void TestGetPrototypeFromContainerGenericArgs() { var container = new DependencyInjector(new ServiceConfiguration(), new MoreConfig()); container.ExpandConfiguration(new ComplexConfig(), new ServiceConfigurationC()).Reconfigure(); Prototype prototype = container.GetObject<Prototype>(); Assert.IsNotNull(prototype); }
public void TestGetObjectsInheritingFromSuperClassFromContainer() { var container = new DependencyInjector(new ServiceConfiguration(), new MoreConfig()); container.ExpandConfiguration(new ComplexConfig()); container.Reconfigure(); Assert.IsTrue(container.ContainsObject<ISomeDomainCmdService>()); Assert.IsTrue(container.ContainsObject<ICommandManager>()); Assert.IsTrue(container.ContainsObject("SomeDomainCmdServiceB")); Assert.IsTrue(container.ContainsObject<IAggregate>()); List<ISomeDomainCmdService> someDomainCmdServices = container.GetAllObjectsInheriting<ISomeDomainCmdService>(); Assert.AreEqual(2, someDomainCmdServices.Count); List<SomeDomainCmdServiceC> someDomainCmdServicesC = container.GetAllObjectsInheriting<SomeDomainCmdServiceC>(); Assert.AreEqual(0, someDomainCmdServicesC.Count); }
static void Main(string[] args) { DependencyInjector.Setup(new BaseDirectoryAssemblyContainer()) .RegisterAssemblies <AssemblyInfoBase>(); if (args != null && args.Length > 0 && args[0].StartsWith("fsmt", StringComparison.OrdinalIgnoreCase)) { new Monitor.FileSystemMonitorTest().Run(); new Monitor.FileSystemMonitorAnotherTest().Run(); Console.ReadKey(); } else if (args != null && args.Length > 0 && args[0].StartsWith("bdact", StringComparison.OrdinalIgnoreCase)) { new DependencyInjection.BaseDirectoryAssemblyContainerTest().Run(); Console.ReadKey(); } else if (args != null && args.Length > 0 && args[0].StartsWith("bdcct", StringComparison.OrdinalIgnoreCase)) { new DependencyInjection.BaseDirectoryConfigurableContainerTest().Run(); Console.ReadKey(); } else if (args != null && args.Length > 0 && args[0].StartsWith("cache", StringComparison.OrdinalIgnoreCase)) { new Caching.CacheContainerBaseTest().Run(); Console.ReadKey(); } else if (args != null && args.Length > 0 && args[0].StartsWith("sfct", StringComparison.OrdinalIgnoreCase)) { new Configuring.StaticFileConfigurerTest().Run1(); Console.ReadKey(); } else if (args != null && args.Length > 0 && args[0].StartsWith("dpgt", StringComparison.OrdinalIgnoreCase)) { new DynamicProxy.DynamicProxyGeneratorTest().Run(); Console.ReadKey(); } else if (args != null && args.Length > 0 && args[0].StartsWith("jft", StringComparison.OrdinalIgnoreCase)) { new Formatter.JsonFormatterTest().Run(); Console.ReadKey(); } else if (args != null && args.Length > 0 && args[0].StartsWith("jfpt", StringComparison.OrdinalIgnoreCase)) { new Formatter.JsonFormatterPerformanceTest().Run(); Console.ReadKey(); } else if (args != null && args.Length > 0 && args[0].StartsWith("flt", StringComparison.OrdinalIgnoreCase)) { new Logging.FileLoggerTest().Run(); Console.ReadKey(); } else if (args != null && args.Length > 0 && args[0].StartsWith("tcplot", StringComparison.OrdinalIgnoreCase)) { new Network.Socket.TcpListenerObjectTest().Run(); Console.ReadKey(); } else if (args != null && args.Length > 0 && args[0].StartsWith("dcct", StringComparison.OrdinalIgnoreCase)) { new EntityFramework.DatabaseCommandConfigurationTest().Run(); Console.ReadKey(); } else if (args != null && args.Length > 0 && args[0].StartsWith("rt", StringComparison.OrdinalIgnoreCase)) { new Data.ReplicatorTest().Run(); Console.ReadKey(); } else if (args != null && args.Length > 0 && args[0].StartsWith("ct", StringComparison.OrdinalIgnoreCase)) { new Data.ComparerTest().Run(); Console.ReadKey(); } else if (args != null && args.Length > 0 && args[0].StartsWith("jdt", StringComparison.OrdinalIgnoreCase)) { new Jobs.JobDispatcherTest().Run(); Console.ReadKey(); } }
public DiServiceHost(DependencyInjector container, Type serviceType, params Uri[] baseAddresses) : base(serviceType, baseAddresses) { this.container = container; }
public Stream CreateClientStream(TestContext ctx, Connection connection, Socket socket) { if ((EffectiveFlags & InstrumentationFlags.NeedClientInstrumentation) == 0) { throw ctx.AssertFail("CreateClientStream()"); } var name = string.Format("Client:{0}", EffectiveType); var ownsSocket = !HasFlag(InstrumentationFlags.ReuseClientSocket); var instrumentation = new StreamInstrumentation(ctx, name, socket, ownsSocket); var setup = DependencyInjector.Get <IConnectionFrameworkSetup> (); switch (EffectiveType) { case StreamInstrumentationType.VerifyAsyncStreamCalls: instrumentation.RequireAsync = true; if (setup.UsingDotNet) { instrumentation.AllowBeginEndAsync = true; instrumentation.AllowSyncFlush = true; } break; } if (Interlocked.CompareExchange(ref clientInstrumentation, instrumentation, null) != null) { throw new InternalErrorException(); } LogDebug(ctx, 4, "CreateClientStream()"); if (!HasFlag(InstrumentationFlags.ClientStream)) { return(instrumentation); } instrumentation.OnNextRead(ReadHandler); return(instrumentation); async Task <int> ReadHandler(byte[] buffer, int offset, int size, StreamInstrumentation.AsyncReadFunc func, CancellationToken cancellationToken) { ctx.Assert(Client.Stream, Is.Not.Null); ctx.Assert(Client.SslStream, Is.Not.Null); ctx.Assert(Client.SslStream.IsAuthenticated, Is.False); switch (EffectiveType) { case StreamInstrumentationType.ClientHandshake: LogDebug(ctx, 4, "CreateClientStream(): client handshake"); break; case StreamInstrumentationType.ReadDuringClientAuth: await ctx.AssertException <InvalidOperationException> (ReadClient).ConfigureAwait(false); break; case StreamInstrumentationType.ShortReadDuringClientAuth: if (size <= 5) { instrumentation.OnNextRead(ReadHandler); } size = 1; break; case StreamInstrumentationType.VerifyAsyncStreamCalls: break; default: throw ctx.AssertFail(EffectiveType); } return(await func(buffer, offset, size, cancellationToken)); } Task <int> ReadClient() { const int bufferSize = 100; return(Client.Stream.ReadAsync(new byte[bufferSize], 0, bufferSize)); } }
public ExceptionMiddleware(IHostingEnvironment environment, RequestDelegate request) { _environment = environment; _logger = DependencyInjector.GetService <ILogger>(); _request = request; }
public ApplicationTest() { DependencyInjector.RegisterServices(); DependencyInjector.AddDbContextInMemoryDatabase <DatabaseContext>(); UserApplication = DependencyInjector.GetService <IUserApplication>(); }
public ClassActivator(IDependencyLocator activator, DependencyInjector injector) { Activator = activator; Injector = injector; }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2); DependencyInjector.Configure(services); }
public AppleCertificateHost(CertificateResourceType type) { CertificateAndKey = ResourceManager.GetCertificateWithKey(type); provider = DependencyInjector.Get <IAppleCertificateProvider> (); AppleCertificate = provider.GetAppleCertificate(CertificateAndKey); }
public void Initialize() { #if DEAD_CODE DependencyInjector.RegisterDependency <IAppleCertificateProvider> (() => new AppleCertificateProvider()); #endif }
public static SslStreamTestParameters GetParameters(TestContext ctx, ConnectionTestCategory category, ConnectionTestType type) { var certificateProvider = DependencyInjector.Get <ICertificateProvider> (); var acceptAll = certificateProvider.AcceptAll(); var rejectAll = certificateProvider.RejectAll(); var acceptNull = certificateProvider.AcceptNull(); var acceptSelfSigned = certificateProvider.AcceptThisCertificate(ResourceManager.SelfSignedServerCertificate); var acceptFromLocalCA = certificateProvider.AcceptFromCA(ResourceManager.LocalCACertificate); var name = GetTestName(category, type); switch (type) { case ConnectionTestType.Default: return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate) { ClientCertificateValidator = acceptAll }); case ConnectionTestType.AcceptFromLocalCA: return(new SslStreamTestParameters(category, type, name, ResourceManager.ServerCertificateFromCA) { ClientCertificateValidator = acceptFromLocalCA }); case ConnectionTestType.NoValidator: // The default validator only allows ResourceManager.SelfSignedServerCertificate. return(new SslStreamTestParameters(category, type, name, ResourceManager.ServerCertificateFromCA) { ExpectClientException = true }); case ConnectionTestType.RejectAll: // Explicit validator overrides the default ServicePointManager.ServerCertificateValidationCallback. return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate) { ExpectClientException = true, ClientCertificateValidator = rejectAll }); case ConnectionTestType.UnrequestedClientCertificate: // Provide a client certificate, but do not require it. return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate) { ClientCertificate = ResourceManager.PenguinCertificate, ClientCertificateValidator = acceptSelfSigned, ServerCertificateValidator = acceptNull }); case ConnectionTestType.RequestClientCertificate: /* * Request client certificate, but do not require it. * * FIXME: * SslStream with Mono's old implementation fails here. */ return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate) { ClientCertificate = ResourceManager.MonkeyCertificate, ClientCertificateValidator = acceptSelfSigned, AskForClientCertificate = true, ServerCertificateValidator = acceptFromLocalCA }); case ConnectionTestType.RequireClientCertificate: // Require client certificate. return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate) { ClientCertificate = ResourceManager.MonkeyCertificate, ClientCertificateValidator = acceptSelfSigned, AskForClientCertificate = true, RequireClientCertificate = true, ServerCertificateValidator = acceptFromLocalCA }); case ConnectionTestType.OptionalClientCertificate: /* * Request client certificate without requiring one and do not provide it. * * To ask for an optional client certificate (without requiring it), you need to specify a custom validation * callback and then accept the null certificate with `SslPolicyErrors.RemoteCertificateNotAvailable' in it. * * FIXME: * Mono with the old TLS implementation throws SecureChannelFailure. */ return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate) { ClientCertificateValidator = acceptSelfSigned, AskForClientCertificate = true, ServerCertificateValidator = acceptNull }); case ConnectionTestType.RejectClientCertificate: // Reject client certificate. return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate) { ClientCertificate = ResourceManager.MonkeyCertificate, ClientCertificateValidator = acceptSelfSigned, ServerCertificateValidator = rejectAll, AskForClientCertificate = true, ExpectClientException = true, ExpectServerException = true }); case ConnectionTestType.MissingClientCertificate: // Missing client certificate. return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate) { ClientCertificateValidator = acceptSelfSigned, AskForClientCertificate = true, RequireClientCertificate = true, ExpectClientException = true, ExpectServerException = true }); case ConnectionTestType.MustNotInvokeGlobalValidator: return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate) { ClientCertificateValidator = acceptAll, GlobalValidationFlags = GlobalValidationFlags.MustNotInvoke }); case ConnectionTestType.MustNotInvokeGlobalValidator2: return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate) { GlobalValidationFlags = GlobalValidationFlags.MustNotInvoke, ExpectClientException = true }); case ConnectionTestType.SyncAuthenticate: return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate) { ClientCertificateValidator = acceptAll, SslStreamFlags = SslStreamFlags.SyncAuthenticate }); default: throw ctx.AssertFail("Invalid ConnectionTestType: `{0}'.", type); } }
public MantenimientoFacturaElectronica() { Inicializador.Init(); facturaElectronica = DependencyInjector.Retrieve <GenericRepository <ServicioFacturaElectronica> >(); log = new ManejoErrores(); }
public void TestGetObjectFromContainer() { var container = new DependencyInjector(new ServiceConfiguration(), new MoreConfig()); container.ExpandConfiguration(new ComplexConfig(), new ServiceConfigurationC()); container.Reconfigure(); Assert.IsTrue(container.ContainsObject<ISomeDomainCmdService>()); Assert.IsTrue(container.ContainsObject<ICommandManager>()); Assert.IsTrue(container.ContainsObject("SomeDomainCmdServiceB")); Assert.IsTrue(container.ContainsObject<IAggregate>()); IAggregate aggregate = container.GetObject<IAggregate>(); Assert.IsNotNull(aggregate); var b = container.GetObject("SomeDomainCmdServiceB"); Assert.IsNotNull(b); // If some instance uniquely implements interface but the object definition id is specified, can it still be retrieved through the interface?? ISomeNewDomainCmdService newCmdService = container.GetObject<ISomeNewDomainCmdService>(); Assert.IsNotNull(newCmdService); SomeNewDomainCmdService newCmdService2 = container.GetObject<SomeNewDomainCmdService>(); Assert.IsNotNull(newCmdService2); var serviceD = container.GetObject<SomeDomainCmdServiceD>("D"); Assert.Throws<DependencyInjectorGetObjectException>(() => container.GetObject<ISomeDomainCmdService>()); Assert.Throws<DependencyInjectorGetObjectException>(() => container.GetObject<SomeDomainCmdServiceD>()); Assert.Throws<DependencyInjectorGetObjectException>(() => container.GetObject<SomeDomainCmdServiceD>("E")); Assert.Throws<DependencyInjectorGetObjectException>(() => container.GetObject<INotImplementedInterface>()); }
static bool IsMobile() { var support = DependencyInjector.Get <IPortableSupport> (); return(support.IsMobile); }
public void ShouldCreateATreeWithStructs() { StructTree tree = new DependencyInjector().CreateAndInjectDependencies <StructTree>().rootBean; Assert.IsNotNull(tree.structChild); }
public AppleCertificateHost(X509Certificate certificate) { CertificateAndKey = certificate; provider = DependencyInjector.Get <IAppleCertificateProvider> (); AppleCertificate = provider.GetAppleCertificate(CertificateAndKey); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1); DependencyInjector.RegisterServices(services); SwaggerConfig.AddSwagger(services); }
protected override void Start() { base.Start(); m_InputOverride = AtfInput.BASE_INPUT; DependencyInjector.InjectType(m_InputOverride.GetType()); }
public void GivenCreate_WhenConfigurationIsNotSpecified_ThenThrowsArgumentException() { var dependencyInjector = new DependencyInjector(); Assert.Throws <ArgumentException>(() => dependencyInjector.Create <IBasicClass>()); }
public static void AddDependencyInjectionCustom(this IServiceCollection services, IConfiguration configuration) { DependencyInjector.RegisterServices(services); DependencyInjector.AddDbContext <DatabaseContext>(configuration.GetConnectionString(nameof(DatabaseContext))); DependencyInjector.GetService <DatabaseContext>().Seed(); }
public IEncryptionTestHost CreateInstance(TestContext context) { var provider = DependencyInjector.Get <ICryptoProvider> (); return(provider.GetEncryptionTestHost(ProviderType, GetParameters())); }
public void Init() { mockNetworkClient = new MockNetworkClient(); // Replace the real networkClient with mock object, it will be injected later into FirstScreen component DependencyInjector.ReplaceComponent <NetworkClient>(mockNetworkClient); }
private Tuple <DependencyInjector, DependencyInjector, DependencyInjector> GetNewClassInjector(IActivatorTree tree) { var type = tree.Key.ReturnType; if (type.IsAbstract) { throw new Exception("Unable to locate Abstract class : " + type.Name); } if (type.IsInterface) { throw new Exception("Unable to locate Interface : " + type.Name); } DependencyInjector activator = null; DependencyInjector activatorCtor = null; DependencyInjector activatorAfter = null; var types = new Stack <Type>(); var t = type; while (t != null) { types.Push(t); t = t.BaseType; } while (types.Count > 0) { t = types.Pop(); foreach (var p in t.GetMembers(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)) { foreach (var attr in p.GetCustomAttributes <ImportAttribute>()) { var ctx = ImportContext.Get(type, p).Get(typeof(IActivator)); var l = GetLocator(new ActivatorTree(tree, ctx)); var a = (IActivator)(l(RuntimeImportContext.GetStatic(null, ctx), null)); if (p is ConstructorInfo ci) { activatorCtor = a.GetActivator(GetLocator, new ActivatorTree(tree, ImportContext.Get(type, p))); } else { switch (attr.Location) { case InjectLocation.BeforeConstructor: activator += a.GetActivator(GetLocator, new ActivatorTree(tree, ImportContext.Get(type, p))); break; case InjectLocation.AfterConstructor: activatorAfter += a.GetActivator(GetLocator, new ActivatorTree(tree, ImportContext.Get(type, p))); break; default: break; } } } } } if (typeof(IInitializer).IsAssignableFrom(type)) { activator += (ctx, args, o) => _initializerMethodInfo.Invoke(o, new object [] { ctx, args }); } foreach (var k in _initializers) { if (k.Key.IsAssignableFrom(type)) { foreach (var action in k.Value) { activator += action; } } } return(new Tuple <DependencyInjector, DependencyInjector, DependencyInjector>(activator, activatorCtor, activatorAfter)); }
static SimpleConnectionParameters Create(TestContext ctx, InstrumentationCategory category, SimpleConnectionType type) { var parameters = CreateParameters(category, type); var provider = DependencyInjector.Get <ICertificateProvider> (); var acceptSelfSigned = provider.AcceptThisCertificate(ResourceManager.SelfSignedServerCertificate); var acceptFromCA = provider.AcceptFromCA(ResourceManager.LocalCACertificate); switch (type) { case SimpleConnectionType.Simple: break; case SimpleConnectionType.ValidateCertificate: parameters.ServerCertificate = ResourceManager.ServerCertificateFromCA; parameters.ClientCertificateValidator = acceptFromCA; break; case SimpleConnectionType.SimpleTls10: parameters.ProtocolVersion = ProtocolVersions.Tls10; break; case SimpleConnectionType.SimpleTls11: parameters.ProtocolVersion = ProtocolVersions.Tls11; parameters.ExpectedCipher = CipherSuiteCode.TLS_DHE_RSA_WITH_AES_256_CBC_SHA; break; case SimpleConnectionType.SimpleTls12: parameters.ProtocolVersion = ProtocolVersions.Tls12; parameters.ExpectedCipher = CipherSuiteCode.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384; break; case SimpleConnectionType.SelectCiphersTls10: parameters.ProtocolVersion = ProtocolVersions.Tls10; break; case SimpleConnectionType.SelectCiphersTls11: parameters.ProtocolVersion = ProtocolVersions.Tls11; break; case SimpleConnectionType.SelectCiphersTls12: parameters.ProtocolVersion = ProtocolVersions.Tls12; break; case SimpleConnectionType.RequestClientCertificate: /* * Request client certificate, but do not require it. * * FIXME: * SslStream with Mono's old implementation fails here. */ parameters.ClientCertificate = ResourceManager.MonkeyCertificate; parameters.ClientCertificateValidator = acceptSelfSigned; parameters.AskForClientCertificate = true; parameters.ServerCertificateValidator = acceptFromCA; break; case SimpleConnectionType.RequireClientCertificateRSA: /* * Require client certificate. * */ parameters.ClientCertificate = ResourceManager.MonkeyCertificate; parameters.ClientCertificateValidator = acceptSelfSigned; parameters.RequireClientCertificate = true; parameters.ServerCertificateValidator = acceptFromCA; parameters.ServerCiphers = new CipherSuiteCode[] { CipherSuiteCode.TLS_RSA_WITH_AES_128_CBC_SHA }; break; case SimpleConnectionType.RequireClientCertificateDHE: /* * Require client certificate. * */ parameters.ClientCertificate = ResourceManager.MonkeyCertificate; parameters.ClientCertificateValidator = acceptSelfSigned; parameters.RequireClientCertificate = true; parameters.ServerCertificateValidator = acceptFromCA; parameters.ServerCiphers = new CipherSuiteCode[] { CipherSuiteCode.TLS_DHE_RSA_WITH_AES_256_CBC_SHA }; break; case SimpleConnectionType.CipherSelectionOrder: parameters.ProtocolVersion = ProtocolVersions.Tls12; parameters.ClientCiphers = new CipherSuiteCode[] { CipherSuiteCode.TLS_RSA_WITH_AES_128_CBC_SHA, CipherSuiteCode.TLS_DHE_RSA_WITH_AES_128_CBC_SHA }; parameters.ExpectedServerCipher = CipherSuiteCode.TLS_RSA_WITH_AES_128_CBC_SHA; break; case SimpleConnectionType.CipherSelectionOrder2: parameters.ProtocolVersion = ProtocolVersions.Tls12; parameters.ClientCiphers = new CipherSuiteCode[] { CipherSuiteCode.TLS_DHE_RSA_WITH_AES_128_CBC_SHA, CipherSuiteCode.TLS_RSA_WITH_AES_128_CBC_SHA }; parameters.ExpectedServerCipher = CipherSuiteCode.TLS_DHE_RSA_WITH_AES_128_CBC_SHA; break; case SimpleConnectionType.MartinTest: goto case SimpleConnectionType.SimpleTls12; default: ctx.AssertFail("Unsupported connection type: '{0}'.", type); break; } return(parameters); }
public void Initializer(Type type, DependencyInjector action) { var list = _initializers.GetOrAdd(type, t => new List <DependencyInjector>()); list.Add(action); }
public void Initialize() { DependencyInjector.RegisterDependency <WebTestFeatures> (() => new WebTestFeatures()); }
static void Main() { DependencyInjector injector = new DependencyInjector(); RunApplication(injector.container); }
public DiServiceHostFactoryIntegration(DependencyInjector container) { DiServiceHostFactoryIntegration.container = container; }
public HashTest() { DependencyInjector.RegisterServices(); Hash = DependencyInjector.GetService <IHash>(); }