public override void Verify(Adapters.IContainerAdapter container)
{
if (!container.SupportsCombined)
{
return;
}
if (Combined1.Instances != this.LoopCount ||
Combined2.Instances != this.LoopCount ||
Combined3.Instances != this.LoopCount)
{
throw new Exception(string.Format("Combined count must be {0}", this.LoopCount));
}
if (Transient1.Instances != this.LoopCount ||
Transient2.Instances != this.LoopCount ||
Transient3.Instances != this.LoopCount)
{
throw new Exception(string.Format("Transient count must be {0}", this.LoopCount));
}
if (Singleton1.Instances > 1 || Singleton2.Instances > 1 || Singleton2.Instances > 1)
{
throw new Exception("Singleton instance count must be 1. Container: " + container.Name);
}
}
public override BenchmarkResult Measure(Adapters.IContainerAdapter container)
{
return(new BenchmarkResult(this, container)
{
Time = base.Measure <ISingleton1, ISingleton2, ISingleton3>(container)
});
}
public override void Warmup(Adapters.IContainerAdapter container)
{
if (!container.SupportsChildContainer)
{
return;
}
using (var childContainer = container.CreateChildContainerAdapter())
{
childContainer.Prepare();
ICombined1 scopedCombined1 = (ICombined1)childContainer.Resolve(typeof(ICombined1));
ICombined2 scopedCombined2 = (ICombined2)childContainer.Resolve(typeof(ICombined2));
ICombined3 scopedCombined3 = (ICombined3)childContainer.Resolve(typeof(ICombined3));
if (scopedCombined1 == null || scopedCombined2 == null || scopedCombined3 == null)
{
throw new Exception(string.Format("Child Container {0} could not create type {1}", container.Name, typeof(ICombined1)));
}
if (!(scopedCombined1 is ScopedCombined1) || !(scopedCombined2 is ScopedCombined2) ||
!(scopedCombined3 is ScopedCombined3))
{
throw new Exception(string.Format(
"Child Container {0} resolved type incorrectly should have been {1} but was {2}",
container.Name,
typeof(ICombined1),
scopedCombined1.GetType()));
}
}
ScopedCombined1.Instances = 0;
ScopedCombined2.Instances = 0;
ScopedCombined3.Instances = 0;
}
public override void Verify(Adapters.IContainerAdapter container)
{
if (Singleton1.Instances != this.LoopCount)
{
throw new Exception(string.Format("Singleton1 count must be {0}", this.LoopCount));
}
}
public override BenchmarkResult Measure(Adapters.IContainerAdapter container)
{
return(new BenchmarkResult(this, container)
{
Time = base.Measure <ICombined1, ICombined2, ICombined3>(container)
});
}
public override BenchmarkResult Measure(Adapters.IContainerAdapter container)
{
var result = new BenchmarkResult(this, container);
if (container.SupportsInterception)
{
BenchmarkBase.CollectMemory();
var watch = new Stopwatch();
watch.Start();
for (int i = 0; i < BenchmarkBase.LoopCount; i++)
{
var result1 = (ICalculator1)container.ResolveProxy(typeof(ICalculator1));
var result2 = (ICalculator2)container.ResolveProxy(typeof(ICalculator2));
var result3 = (ICalculator3)container.ResolveProxy(typeof(ICalculator3));
result1.Add(5, 10);
result2.Add(5, 10);
result3.Add(5, 10);
}
watch.Stop();
result.Time = watch.ElapsedMilliseconds;
}
return(result);
}
public override BenchmarkResult Measure(Adapters.IContainerAdapter container)
{
return(new BenchmarkResult(this, container)
{
Time = base.Measure <ITransient1, ITransient2, ITransient3>(container)
});
}
public override void Verify(Adapters.IContainerAdapter container)
{
if (Singleton1.Instances > 1 || Singleton2.Instances > 1 || Singleton2.Instances > 1)
{
throw new Exception("Singleton instance count must be 1. Container: " + container.Name);
}
}
public override void Verify(Adapters.IContainerAdapter container)
{
if (Transient1.Instances != Benchmark.LoopCount ||
Transient2.Instances != Benchmark.LoopCount ||
Transient3.Instances != Benchmark.LoopCount)
{
throw new Exception(string.Format("Transient count must be {0}", Benchmark.LoopCount));
}
}
public override void Verify(Adapters.IContainerAdapter container)
{
if (Complex1.Instances != Benchmark.LoopCount ||
Complex2.Instances != Benchmark.LoopCount ||
Complex3.Instances != Benchmark.LoopCount)
{
throw new Exception(string.Format("Complex count must be {0}", Benchmark.LoopCount));
}
}
public override BenchmarkResult Measure(Adapters.IContainerAdapter container)
{
var result = new BenchmarkResult(this, container);
if (container.SupportGeneric)
{
result.Time = base.Measure <ImportGeneric <int>, ImportGeneric <float>, ImportGeneric <object> >(container);
}
return(result);
}
public override BenchmarkResult Measure(Adapters.IContainerAdapter container)
{
var result = new BenchmarkResult(this, container);
if (container.SupportsMultiple)
{
result.Time = base.Measure <ImportMultiple1, ImportMultiple2, ImportMultiple3>(container);
}
return(result);
}
public override BenchmarkResult Measure(Adapters.IContainerAdapter container)
{
var result = new BenchmarkResult(this, container);
if (container.SupportsPropertyInjection)
{
result.Time = base.Measure <IComplexPropertyObject1, IComplexPropertyObject2, IComplexPropertyObject3>(container);
}
return(result);
}
public override BenchmarkResult Measure(Adapters.IContainerAdapter container)
{
var result = new BenchmarkResult(this, container);
if (container.SupportsConditional)
{
result.Time = base.Measure <ImportConditionObject1, ImportConditionObject2, ImportConditionObject3>(container);
}
return(result);
}
public override void Verify(Adapters.IContainerAdapter container)
{
// Cauldron has an instance count of 0, which seems to be caused by the code generation
if (container.GetType().Equals(typeof(CauldronContainerAdapter)) && Singleton1.Instances == 0)
{
return;
}
if (Singleton1.Instances != this.LoopCount)
{
throw new Exception(string.Format("Singleton1 count must be {0} but was {1}", this.LoopCount, Singleton1.Instances));
}
}
public override void Verify(Adapters.IContainerAdapter container)
{
if (!container.SupportsConditional)
{
return;
}
if (ImportConditionObject1.Instances != this.LoopCount ||
ImportConditionObject2.Instances != this.LoopCount ||
ImportConditionObject3.Instances != this.LoopCount)
{
throw new Exception(string.Format("ImportConditionObject count must be {0}", this.LoopCount));
}
}
public override void Verify(Adapters.IContainerAdapter container)
{
if (!container.SupportsTransient)
{
return;
}
if (Transient1.Instances != this.LoopCount ||
Transient2.Instances != this.LoopCount ||
Transient3.Instances != this.LoopCount)
{
throw new Exception(string.Format("Transient count must be {0}", this.LoopCount));
}
}
public override void Verify(Adapters.IContainerAdapter container)
{
if (!container.SupportGeneric)
{
return;
}
if (ImportGeneric <int> .Instances != Benchmark.LoopCount ||
ImportGeneric <float> .Instances != Benchmark.LoopCount ||
ImportGeneric <object> .Instances != Benchmark.LoopCount)
{
throw new Exception(string.Format("ImportGeneric count must be {0}", Benchmark.LoopCount));
}
}
public override void Verify(Adapters.IContainerAdapter container)
{
if (!container.SupportsPropertyInjection)
{
return;
}
if (ComplexPropertyObject1.Instances != BenchmarkBase.LoopCount ||
ComplexPropertyObject2.Instances != BenchmarkBase.LoopCount ||
ComplexPropertyObject3.Instances != BenchmarkBase.LoopCount)
{
throw new Exception(string.Format("ComplexPropertyObject count must be {0}", BenchmarkBase.LoopCount));
}
}
public override void Verify(Adapters.IContainerAdapter container)
{
if (!container.SupportsChildContainer)
{
return;
}
if (ScopedCombined1.Instances != this.LoopCount ||
ScopedCombined2.Instances != this.LoopCount ||
ScopedCombined3.Instances != this.LoopCount)
{
throw new Exception(string.Format("ScopedCombined count must be {0}", this.LoopCount));
}
}
public override void Verify(Adapters.IContainerAdapter container)
{
if (!container.SupportsMultiple)
{
return;
}
if (ImportMultiple1.Instances != BenchmarkBase.LoopCount ||
ImportMultiple2.Instances != BenchmarkBase.LoopCount ||
ImportMultiple3.Instances != BenchmarkBase.LoopCount)
{
throw new Exception(string.Format("ImportMultiple count must be {0}", BenchmarkBase.LoopCount));
}
}
public override void Verify(Adapters.IContainerAdapter container)
{
if (!container.SupportsInterception)
{
return;
}
if (Calculator1.Instances != this.LoopCount ||
Calculator2.Instances != this.LoopCount ||
Calculator3.Instances != this.LoopCount)
{
throw new Exception(string.Format("Calculator count must be {0}", this.LoopCount));
}
}
public override void Warmup(Adapters.IContainerAdapter container)
{
var complex1 = (IComplex1)container.Resolve(typeof(IComplex1));
var complex2 = (IComplex2)container.Resolve(typeof(IComplex2));
var complex3 = (IComplex3)container.Resolve(typeof(IComplex3));
if (complex1 == null || complex2 == null || complex3 == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.Name, typeof(IComplex1)));
}
Complex1.Instances = 0;
Complex2.Instances = 0;
Complex3.Instances = 0;
}
public override void Warmup(Adapters.IContainerAdapter container)
{
var transient1 = (ITransient1)container.Resolve(typeof(ITransient1));
var transient2 = (ITransient2)container.Resolve(typeof(ITransient2));
var transient3 = (ITransient3)container.Resolve(typeof(ITransient3));
if (transient1 == null || transient2 == null || transient3 == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.Name, typeof(ITransient1)));
}
Transient1.Instances = 0;
Transient2.Instances = 0;
Transient3.Instances = 0;
}
public override void Warmup(Adapters.IContainerAdapter container)
{
Singleton1.Instances = 0;
Singleton2.Instances = 0;
Singleton3.Instances = 0;
var singleton1 = (ISingleton1)container.Resolve(typeof(ISingleton1));
var singleton2 = (ISingleton2)container.Resolve(typeof(ISingleton2));
var singleton3 = (ISingleton3)container.Resolve(typeof(ISingleton3));
if (singleton1 == null || singleton2 == null || singleton3 == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.Name, typeof(ISingleton1)));
}
}
public override void Warmup(Adapters.IContainerAdapter container)
{
if (!container.SupportsMultiple)
{
return;
}
var importMultiple1 = (ImportMultiple1)container.Resolve(typeof(ImportMultiple1));
var importMultiple2 = (ImportMultiple2)container.Resolve(typeof(ImportMultiple2));
var importMultiple3 = (ImportMultiple3)container.Resolve(typeof(ImportMultiple3));
if (importMultiple1 == null || importMultiple2 == null || importMultiple3 == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.Name, typeof(ImportMultiple1)));
}
ImportMultiple1.Instances = 0;
ImportMultiple2.Instances = 0;
ImportMultiple3.Instances = 0;
}
public override void Warmup(Adapters.IContainerAdapter container)
{
if (!container.SupportGeneric)
{
return;
}
var generic1 = (ImportGeneric <int>)container.Resolve(typeof(ImportGeneric <int>));
var generic2 = (ImportGeneric <float>)container.Resolve(typeof(ImportGeneric <float>));
var generic3 = (ImportGeneric <object>)container.Resolve(typeof(ImportGeneric <object>));
if (generic1 == null || generic2 == null || generic3 == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.Name, typeof(ImportGeneric <>)));
}
ImportGeneric <int> .Instances = 0;
ImportGeneric <float> .Instances = 0;
ImportGeneric <object> .Instances = 0;
}
public override void Warmup(Adapters.IContainerAdapter container)
{
if (!container.SupportsInterception)
{
return;
}
var calculator1 = (ICalculator1)container.ResolveProxy(typeof(ICalculator1));
calculator1.Add(1, 2);
var calculator2 = (ICalculator2)container.ResolveProxy(typeof(ICalculator2));
calculator2.Add(1, 2);
var calculator3 = (ICalculator3)container.ResolveProxy(typeof(ICalculator3));
calculator3.Add(1, 2);
Calculator1.Instances = 0;
Calculator2.Instances = 0;
Calculator3.Instances = 0;
}
public override void Warmup(Adapters.IContainerAdapter container)
{
if (!container.SupportsPropertyInjection)
{
return;
}
var complex1 = (IComplexPropertyObject1)container.Resolve(typeof(IComplexPropertyObject1));
var complex2 = (IComplexPropertyObject2)container.Resolve(typeof(IComplexPropertyObject2));
var complex3 = (IComplexPropertyObject3)container.Resolve(typeof(IComplexPropertyObject3));
if (complex1 == null || complex2 == null || complex3 == null)
{
throw new Exception(string.Format("Container {0} could not create type {1}", container.Name, typeof(IComplexPropertyObject1)));
}
complex1.Verify(container.Name);
complex1.Verify(container.Name);
complex1.Verify(container.Name);
ComplexPropertyObject1.Instances = 0;
ComplexPropertyObject2.Instances = 0;
ComplexPropertyObject3.Instances = 0;
}
public ContainerAdapterInfo(Adapters.IContainerAdapter container)
{
this.Name = container.Name;
this.Url = container.Url;
this.Version = container.Version;
}
