public T Resolve(IInstanceGenerator instanceGenerator)
{
try
{
_perTypeNestingLimit.AddNestingFor <T>();
if (!_perTypeNestingLimit.IsReachedFor <T>())
{
return(_fakeChain.Resolve(instanceGenerator));
}
else
{
try
{
return(instanceGenerator.Dummy <T>());
}
catch (TargetInvocationException e)
{
return(default(T));
}
catch (MemberAccessException e)
{
return(default(T));
}
catch (ArgumentException e)
{
return(default(T));
}
}
}
finally
{
_perTypeNestingLimit.RemoveNestingFor <T>();
}
}
public object List(Type type, IInstanceGenerator instanceGenerator)
{
return(ResultOfGenericVersionOfMethod(
type,
MethodBase.GetCurrentMethod(),
instanceGenerator));
}
/// <summary>
/// Add a managed generator to the CobbleContext.
/// </summary>
/// <param name="generator">An <see cref="IInstanceGenerator"/> which is responsible for constructing the object.</param>
public void AddManaged(IInstanceGenerator generator)
{
if (generator == null)
{
throw new ArgumentNullException(nameof(generator));
}
if (!_firstStage) // If Execute has already been called, create an instance right away and call all UnitLoaded functions.
{
_instanceGenerators.Add(generator);
}
else
{
var inst = CreateInstance(generator, _implementations);
PushInstanceProvides(generator, inst);
foreach (var prov in generator.Provides)
{
if (!_lateInjectInstances.TryGetValue(prov, out var set))
{
continue;
}
foreach (var late in set)
{
late.GetType().GetRuntimeMethod(nameof(ILateInject <object> .UnitLoaded), new[] { prov })?.Invoke(late, new [] { inst });
}
}
}
}
/// <summary>
/// Generates the sequence of pairs of type <typeparamref name="T"/>
/// using specified instance generator.
/// </summary>
/// <param name="generator">The instance generator to use.</param>
/// <param name="random">The random generator to use.</param>
/// <param name="equalityProbability">The item equality probability.</param>
/// <returns>Described sequence.</returns>
public static IEnumerable <Pair <T> > GetPairs(IInstanceGenerator <T> generator, Random random, double equalityProbability)
{
bool isValueType = typeof(T).IsValueType;
bool isCloneable = typeof(ICloneable).IsAssignableFrom(typeof(T));
while (true)
{
T x = generator.GetInstance(random);
if (random.NextDouble() < equalityProbability)
{
T y;
if (isValueType)
{
y = x;
}
else if (isCloneable)
{
y = (T)((ICloneable)x).Clone();
}
else
{
y = x;
}
yield return(new Pair <T>(x, x));
}
else
{
yield return(new Pair <T>(x, generator.GetInstance(random)));
}
}
}
public void ArrayTest <T>(int length, int count, double equalityProbability)
{
Random r = RandomManager.CreateRandom(SeedVariatorType.CallingMethod);
IInstanceGenerator <T> g = InstanceGeneratorProvider.Default.GetInstanceGenerator <T>();
IEnumerator <T> sequence = InstanceGenerationUtils <T> .GetInstances(g, r, equalityProbability).GetEnumerator();
sequence.MoveNext();
T[] array = new T[length];
for (int i = 0; i < length; i++, sequence.MoveNext())
{
array[i] = sequence.Current;
}
AdvancedComparerStruct <T> c1 = AdvancedComparer <T> .System;
AdvancedComparerStruct <T> c2 = AdvancedComparer <T> .Default;
if (!TestInfo.IsProfileTestRunning)
{
ArrayComparisonLoop(c1, array, 1);
}
ArrayComparisonLoop(c2, array, 1);
TestLog.Info("Array comparison (equality probability = {0}):", (int)(equalityProbability * 100));
TestLog.Info(" Type: {0}, array length: {1}", typeof(T).GetShortName(), length);
using (IndentManager.IncreaseIndent()) {
TestHelper.CollectGarbage();
if (!TestInfo.IsProfileTestRunning)
{
using (new Measurement("Default comparer", MeasurementOptions.Log, (length - 1) * count))
ArrayComparisonLoop(c1, array, count);
TestHelper.CollectGarbage();
}
using (new Measurement("Xtensive comparer", MeasurementOptions.Log, (length - 1) * count))
ArrayComparisonLoop(c2, array, count);
TestHelper.CollectGarbage();
}
}
/// <summary>
/// Generates the sequence of instances of type <typeparamref name="T"/>
/// using specified instance generator.
/// </summary>
/// <param name="generator">The instance generator to use.</param>
/// <param name="random">The random generator to use.</param>
/// <param name="equalityProbability">The subsequent item equality probability.</param>
/// <returns>Described sequence.</returns>
public static IEnumerable <T> GetInstances(IInstanceGenerator <T> generator, Random random, double equalityProbability)
{
bool isValueType = typeof(T).IsValueType;
bool isCloneable = typeof(ICloneable).IsAssignableFrom(typeof(T));
T x = default(T);
bool first = true;
while (true)
{
if (first || random.NextDouble() >= equalityProbability)
{
x = generator.GetInstance(random);
}
else
{
T y;
if (isValueType)
{
y = x;
}
else if (isCloneable)
{
y = (T)((ICloneable)x).Clone();
}
else
{
y = x;
}
x = y;
}
first = false;
yield return(x);
}
}
private static void InternalSetValue <T>(Xtensive.Tuples.Tuple tuple, int fieldIndex, Random random)
{
IInstanceGenerator <T> generator = InstanceGeneratorProvider.Default.GetInstanceGenerator <T>();
T instance = generator.GetInstance(random);
tuple.SetValue(fieldIndex, instance);
}
// Constructors
/// <summary>
/// <see cref="ClassDocTemplate.Ctor" copy="true" />
/// </summary>
/// <param name="provider">Instance generator provider this generator is bound to.</param>
public WrappingInstanceGenerator(IInstanceGeneratorProvider provider)
: base(provider)
{
BaseGenerator1 = provider.GetInstanceGenerator <TBase1>();
BaseGenerator2 = provider.GetInstanceGenerator <TBase2>();
BaseGenerator3 = provider.GetInstanceGenerator <TBase3>();
}
public T GenerateInstance(IInstanceGenerator instanceGenerator)
{
var generateInstance = (T)_fallbackTypeGenerator.GenerateInstance(instanceGenerator);
_fallbackTypeGenerator.FillFieldsAndPropertiesOf(generateInstance, instanceGenerator);
return(generateInstance);
}
private static void SetValue <T>(ITuple dummyTuple, ITuple tuple, int fieldIndex, Random random)
{
IInstanceGenerator <T> generator = InstanceGeneratorProvider.Default.GetInstanceGenerator <T>();
T instance = generator.GetInstance(random);
dummyTuple.SetValue(fieldIndex, instance);
tuple.SetValue(fieldIndex, instance);
}
public object NewInstanceOf(Type type, IInstanceGenerator instanceGenerator)
{
var typeInfo = type.GetTypeInfo();
var type1 = typeInfo.GetGenericArguments()[0];
var type2 = typeInfo.GetGenericArguments()[1];
return(_factoryMethod.Invoke(type1, type2, instanceGenerator));
}
public ICollection <T> AddManyTo <T>(ICollection <T> collection, int many, IInstanceGenerator instanceGenerator)
{
for (int i = 0; i < many; ++i)
{
collection.Add(instanceGenerator.Instance <T>());
}
return(collection);
}
/// <summary>
/// Initializes a new instance of <see cref="InstanceGeneratorNode" /> with the provided
/// parent.
/// </summary>
/// <param name="parent">The parent.</param>
public InstanceGeneratorNode(IInstanceGenerator parent)
{
if (parent == null)
{
throw new ArgumentNullException("parent");
}
this.parent = parent;
}
/// <summary>
/// Initializes a new instance of <see cref="InstanceGeneratorNode" /> with the provided
/// parent.
/// </summary>
/// <param name="parent">The parent.</param>
public InstanceGeneratorNode(IInstanceGenerator parent)
{
if (parent == null)
{
throw new ArgumentNullException("parent");
}
this.parent = parent;
}
/// <summary>
/// Initializes a new instance of the <see cref="GeneratorStrategy"/> class with the
/// provided parent and attribute provider.
/// </summary>
/// <param name="parent">The parent.</param>
/// <param name="attributeProvider">A description of the requested instance.</param>
protected GeneratorStrategy(IInstanceGenerator parent, ICustomAttributeProvider attributeProvider)
{
if (parent == null)
{
throw new ArgumentNullException("parent");
}
this.parent = parent;
this.attributeProvider = attributeProvider;
}
public ConcurrentBag <T> ConcurrentBag <T>(int length, IInstanceGenerator instanceGenerator)
{
var coll = new ConcurrentBag <T>();
for (int i = 0; i < length; ++i)
{
coll.Add(instanceGenerator.Instance <T>());
}
return(coll);
}
public ConcurrentStack <T> ConcurrentStack <T>(int length, IInstanceGenerator instanceGenerator)
{
var coll = new ConcurrentStack <T>();
for (var i = 0; i < length; ++i)
{
coll.Push(instanceGenerator.Instance <T>());
}
return(coll);
}
public IEnumerable <T> EnumerableWith <T>(IEnumerable <T> included, IInstanceGenerator instanceGenerator)
{
var list = new List <T>();
list.Add(instanceGenerator.Instance <T>());
list.AddRange(included);
list.Add(instanceGenerator.Instance <T>());
return(list);
}
public Dictionary <TKey, TValue> Dictionary <TKey, TValue>(int length, IInstanceGenerator instanceGenerator)
{
var dict = new Dictionary <TKey, TValue>();
for (var i = 0; i < length; ++i)
{
dict.Add(instanceGenerator.Instance <TKey>(), instanceGenerator.Instance <TValue>());
}
return(dict);
}
public SortedList <TKey, TValue> SortedList <TKey, TValue>(int length, IInstanceGenerator instanceGenerator)
{
var list = new SortedList <TKey, TValue>();
for (int i = 0; i < length; ++i)
{
list.Add(instanceGenerator.Instance <TKey>(), instanceGenerator.Instance <TValue>());
}
return(list);
}
public void StringTest()
{
IInstanceGenerator <Guid> generator = InstanceGeneratorProvider.Default.GetInstanceGenerator <Guid>();
Random random = RandomManager.CreateRandom(1, SeedVariatorType.CallingMethod);
for (int i = 0; i < iterationCount * 100; i++)
{
OneValueTest <Guid, string>(generator.GetInstance(random), 1);
}
}
public Dictionary <T, U> DictionaryWithKeys <T, U>(IEnumerable <T> keys, IInstanceGenerator instanceGenerator)
{
var dict = Dictionary <T, U>(0, instanceGenerator);
foreach (var key in keys)
{
dict.Add(key, instanceGenerator.InstanceOf <U>());
}
return(dict);
}
public void Test()
{
TestLog.Info("{0}", DateTime.Now.ToString("yyyy/MM/dd hh:mm:ss.fff %K", CultureInfo.InvariantCulture));
IInstanceGenerator <DateTime> generator = InstanceGeneratorProvider.Default.GetInstanceGenerator <DateTime>();
Random random = RandomManager.CreateRandom(1, SeedVariatorType.CallingMethod);
for (int i = 0; i < iterationCount * 1; i++)
{
TestLog.Info("{0}", generator.GetInstance(random).ToString("yyyy/MM/dd hh:mm:ss.fff %K", CultureInfo.InvariantCulture));
}
}
public IEnumerable <T> EnumerableWithout <T>(T[] excluded, IInstanceGenerator instanceGenerator)
{
var result = new List <T>
{
instanceGenerator.OtherThan(excluded),
instanceGenerator.OtherThan(excluded),
instanceGenerator.OtherThan(excluded)
};
return(result);
}
public T Apply(IInstanceGenerator instanceGenerator)
{
var result = (T)(_proxyGenerator.CreateClassProxy(
typeof(T),
_fallbackTypeGenerator.GenerateConstructorParameters(instanceGenerator).ToArray(),
new AbstractClassInterceptor(_generation,
instanceGenerator.Instance)));
_fallbackTypeGenerator.FillFieldsAndPropertiesOf(result, instanceGenerator);
return(result);
}
public T Resolve(IInstanceGenerator instanceGenerator)
{
if (_resolution.Applies())
{
return(_resolution.Apply(instanceGenerator));
}
else
{
return(_next.Resolve(instanceGenerator));
}
}
public void ParentIsCorrect()
{
// Fixture setup
var parent = new MockInstanceGenerator();
var sut = new TestableInstanceGenerator(parent);
// Exercise system
IInstanceGenerator result = sut.Parent;
// Verify outcome
Assert.AreEqual(parent, result, "Parent");
// Teardown
}
private void PerfTestInternal <T>(int count)
{
// Random random = RandomManager.CreateRandom(SeedVariatorType.CallingMethod);
IInstanceGenerator <T> generator = InstanceGeneratorProvider.Default.GetInstanceGenerator <T>();
T instance1 = generator.GetInstance(random);
T instance2 = generator.GetInstance(random);
Arithmetic <T> arithmetic = Arithmetic <T> .Default;
using (new Measurement(typeof(T).Name, count)) {
for (int i = 0; i < count; i++)
{
arithmetic.Add(instance1, instance2);
}
}
}
internal TestableGeneratorStrategy(IInstanceGenerator parent, ICustomAttributeProvider attributeProvider, Func <ICustomAttributeProvider, bool> canGenerateCallback, Func <ICustomAttributeProvider, object> generateCallback)
: base(parent, attributeProvider)
{
if (canGenerateCallback == null)
{
throw new ArgumentNullException("canGenerateCallback");
}
if (generateCallback == null)
{
throw new ArgumentNullException("generateCallback");
}
this.canGenerateCallback = canGenerateCallback;
this.generateCallback = generateCallback;
}
public T Apply(IInstanceGenerator instanceGenerator)
{
try
{
return(_valueGenerator.ValueOf <T>());
}
catch (AutoFixture.ObjectCreationException)
{
return(_fallbackTypeGenerator.GenerateInstance(instanceGenerator));
}
catch (TargetInvocationException)
{
return(_fallbackTypeGenerator.GenerateInstance(instanceGenerator));
}
}
private void EnumTestInternal <TFrom, TTo>()
{
AdvancedConverter <TFrom, TTo> advancedConverter = AdvancedConverter <TFrom, TTo> .Default;
AdvancedConverter <TTo, TFrom> backwardAdvancedConverter = AdvancedConverter <TTo, TFrom> .Default;
IInstanceGenerator <TFrom> instanceGenerator = InstanceGeneratorProvider.Default.GetInstanceGenerator <TFrom>();
Assert.IsNotNull(advancedConverter);
Assert.IsNotNull(backwardAdvancedConverter);
Assert.IsNotNull(instanceGenerator);
foreach (TFrom from in instanceGenerator.GetInstances(random, enumTestCount))
{
TTo result = advancedConverter.Convert(from);
TFrom backwardResult = backwardAdvancedConverter.Convert(result);
Assert.AreEqual(from, backwardResult);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyBasedInstanceGenerator" /> class
/// with the provided parent.
/// </summary>
/// <param name="parent">The parent generator.</param>
public PropertyBasedInstanceGenerator(IInstanceGenerator parent)
: base(parent)
{
}
internal TestableInstanceGenerator(IInstanceGenerator parent)
: base(parent)
{
this.CanGenerateCallback = ap => false;
this.GenerateCallback = ap => new object();
}
internal TestableGeneratorStrategy(IInstanceGenerator parent, ICustomAttributeProvider attributeProvider, Func<ICustomAttributeProvider, bool> canGenerateCallback, Func<ICustomAttributeProvider, object> generateCallback)
: base(parent, attributeProvider)
{
if (canGenerateCallback == null)
{
throw new ArgumentNullException("canGenerateCallback");
}
if (generateCallback == null)
{
throw new ArgumentNullException("generateCallback");
}
this.canGenerateCallback = canGenerateCallback;
this.generateCallback = generateCallback;
}
internal ParentGeneratorStrategy(IInstanceGenerator parent, ICustomAttributeProvider attributeProvider)
: base(parent, attributeProvider)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="GeneratorStrategy"/> class with the
/// provided parent and attribute provider.
/// </summary>
/// <param name="parent">The parent.</param>
/// <param name="attributeProvider">A description of the requested instance.</param>
protected GeneratorStrategy(IInstanceGenerator parent, ICustomAttributeProvider attributeProvider)
{
if (parent == null)
{
throw new ArgumentNullException("parent");
}
this.parent = parent;
this.attributeProvider = attributeProvider;
}
internal PropertyGeneratorStrategy(IInstanceGenerator parent, ICustomAttributeProvider attributeProvider)
: base(parent, attributeProvider)
{
this.propertyInfo = attributeProvider as PropertyInfo;
}
