public void DelegateResolverConstructorTest() { LogRequestHandler requestHandler = null; // TODO: Initialize to an appropriate value DelegateResolver target = new DelegateResolver(requestHandler); Assert.Inconclusive("TODO: Implement code to verify target"); }
public CashResolver() { cash = new Dictionary <Question, Record[]>(); backupCash = new Dictionary <int, Queue <byte[]> >(); master = new DelegateResolver(cash, backupCash); new Thread(master.ListenAndUpdate).Start(); }
public DependencyCollection AddDependency <TResult>( Type[] contracts, Func <IServiceProvider, TResult> builder, DependencyLifetime lifetime) where TResult : class { var implementation = typeof(TResult); foreach (var contract in contracts) { if (contract.IsAssignableFrom(implementation)) { continue; } var contractName = ReflectionUtils.GetName(contract); var resultName = ReflectionUtils.GetName <TResult>(); throw Error.InvalidOperation($"Type {resultName} is not assignable from {contractName}"); } var resolver = new DelegateResolver <TResult>(builder); var dependency = Dependency.Build(lifetime, contracts, resolver); return(Add(dependency)); }
public TDelegate ExecuteLambda <TDelegate>(Delegate func) where TDelegate : class { var resolver = new DelegateResolver(func); return(func.ResolveMethodTo <TDelegate>(resolver) .ToLambda() .Compile()); }
public TDelegate ExecuteLambdaWithContext <TDelegate, TContext>(Delegate func, TContext context) where TDelegate : class { var resolver = new DelegateResolver(func); return(func.ResolveMethodTo <TDelegate>(resolver) .WithContextOf <TContext>(context) .ToLambda() .Compile()); }
public void HasValidContracts() { var implementation = typeof(BooRepository); var contracts = new[] { implementation }; var resolver = new DelegateResolver(implementation, ctx => new BooRepository(null, null)); var dependency = new ScopedDependency(contracts, resolver); dependency.Contracts.Should().Contain(contracts); ((IDependency)dependency).Contracts.Should().Contain(contracts); }
public DependencyCollection AddDependency <TContract>(Func <IDependencyScope, TContract> builder, DependencyLifetime lifetime) where TContract : class { var contracts = new[] { Typeof <TContract> .Raw }; var resolver = new DelegateResolver <TContract>(builder); var dependency = Dependency.Build(lifetime, contracts, resolver); return(AddDependency(dependency)); }
public void GetFactoryTest() { DelegateResolver target = new DelegateResolver(); // TODO: Initialize to an appropriate value string logName = string.Empty; // TODO: Initialize to an appropriate value ILogFactory expected = null; // TODO: Initialize to an appropriate value ILogFactory actual; actual = target.GetFactory(logName); Assert.AreEqual(expected, actual); Assert.Inconclusive("Verify the correctness of this test method."); }
public void RequestHandlerTest() { DelegateResolver target = new DelegateResolver(); // TODO: Initialize to an appropriate value LogRequestHandler expected = null; // TODO: Initialize to an appropriate value LogRequestHandler actual; target.RequestHandler = expected; actual = target.RequestHandler; Assert.AreEqual(expected, actual); Assert.Inconclusive("Verify the correctness of this test method."); }
public DependencyCollection AddDependency( Type[] contracts, Func <IServiceProvider, object> builder, DependencyLifetime lifetime, Type implementation) { var resolver = new DelegateResolver(implementation, builder); var dependency = Dependency.Build(lifetime, contracts, resolver); return(Add(dependency)); }
public void ResolveTypedInstance() { var builder = new Mock <Func <IServiceProvider, IBooRepository> >(); builder .Setup(b => b.Invoke(_services)) .Returns(_instance); var resolver = new DelegateResolver <IBooRepository>(builder.Object); resolver .Invoking(r => r.Resolve(_contract, _services)) .Should().NotThrow() .Which.Should().Be(_instance); }
public void Updatevalue() { // Arrange var foo = new Foo { Branch = new Branch() }; IBindingResolver resolver = new DelegateResolver(src => ((Foo)src).Branch.Name, (src, value) => ((Foo)src).Branch.Name = (string)value); // Act resolver.Update(foo, "Howard"); // Assert Assert.AreEqual("Howard", foo.Branch.Name); }
public void ResolveValue() { // Arrange var foo = new Foo { Branch = new Branch { Name = "Howard" } }; IBindingResolver resolver = new DelegateResolver(src => ((Foo)src).Branch.Name); // Act var result = resolver.Resolve(foo); // Assert Assert.AreEqual("Howard", result); }
public void DelegateResolverConstructorTest1() { DelegateResolver target = new DelegateResolver(); Assert.Inconclusive("TODO: Implement code to verify target"); }