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