public static IEnumerable <Func <ITestContext, InterfaceMethodData> > GetPossibleVariations(
ITestInterfaceGenerationOptions options)
{
var methodAttributeCombinations = options.MethodAttributeDataBuilder.GetPossibleCombinations(options);
var methodParameterPossibleVariations = MethodParameterData.GetPossibleVariations(options).ToList();
foreach (var attributeData in methodAttributeCombinations)
{
foreach (var returnType in options.InterfaceMethodReturnTypes)
{
Func <ITestContext, InterfaceMethodData> CreateInterfaceMethodDataVariation(IEnumerable <Func <ITestContext, MethodParameterData> > parameters)
{
return(context => new InterfaceMethodData(returnType, "Method" + context.NextId(), attributeData(context).ToArray(), parameters.Select((avaluator) => avaluator(context)).ToArray()));
}
public IEnumerable <Func <ITestContext, IEnumerable <AttributeData> > > GetPossibleCombinations(
ITestInterfaceGenerationOptions options)
{
yield return(c => new AttributeData[0]);
var logLevels = Enum.GetValues(typeof(LogLevel)).Cast <LogLevel>().ToArray();
foreach (var logLevel in logLevels)
{
yield return(c =>
{
return new[] { LogConditionAttributeData.Create(logLevel) };
});
}
}
public Func <ITestContext, InterfaceData[]> GetInheritedInterfaces(ITestInterfaceGenerationOptions options, int count)
{
return(context =>
{
var interfaces = Enumerable.Range(context.NextId(), count).Select(_ => GetInheritedInterfaceData(_, context)).ToArray();
foreach (var @interface in interfaces)
{
var namespaceData = new NamespaceData(@interface.Namespace, @interface);
var compilationEntryData = new CompilationEntryData(options.UsingNamespaces, namespaceData);
context.AddCompilationEntry(compilationEntryData);
}
return interfaces;
});
}
public IEnumerable <Func <ITestContext, IEnumerable <AttributeData> > > GetPossibleCombinations(
ITestInterfaceGenerationOptions options)
{
yield return(c => { return new AttributeData[0]; });
yield return(c =>
{
var message = Guid.NewGuid().ToString();
return new AttributeData[] { LoggerInterfaceMethodAttributeData.Create(LogLevel.Warning, message) };
});
yield return(c =>
{
return new AttributeData[] { LoggerInterfaceMethodAttributeData.Create(LogLevel.Warning) };
});
yield return(c =>
{
var message = Guid.NewGuid().ToString();
return new AttributeData[] { LoggerInterfaceMethodAttributeData.Create(message) };
});
}
public IEnumerable <Func <ITestContext, IEnumerable <AttributeData> > > GetPossibleCombinations(
ITestInterfaceGenerationOptions options)
{
yield return(c => { return new AttributeData[0]; });
yield return(c =>
{
var metricName = "Metric" + Guid.NewGuid();
var unitName = "Unit" + Guid.NewGuid();
return new AttributeData[] { MetricsCollectorMethodAttributeData.Create(metricName, unitName) };
});
yield return(c =>
{
var metricName = "Metric" + Guid.NewGuid();
return new AttributeData[] { MetricsCollectorMethodAttributeData.CreateWithMetricNameOnly(metricName) };
});
yield return(c =>
{
var unitName = "Unit" + Guid.NewGuid();
return new AttributeData[] { MetricsCollectorMethodAttributeData.CreateWithMeasurementUnitNameOnly(unitName) };
});
}
public CompilationUnitDataBuilder(ITestInterfaceGenerationOptions options)
{
_options = options;
}
public IEnumerable <Func <ITestContext, IEnumerable <AttributeData> > > GetPossibleCombinations(ITestInterfaceGenerationOptions options)
{
var attributeToInheritInterfacesNumbers = Enumerable.Range(0, 2);
foreach (var attributeToInheritInterfacesNumber in attributeToInheritInterfacesNumbers)
{
yield return(context =>
{
var interfacesToInherit = Enumerable.Range(context.NextId(), attributeToInheritInterfacesNumber)
.Select(GetBaseTypeInterfaceData).ToArray();
var contextName = "Context_" + context.NextId();
foreach (var interfaceToInherit in interfacesToInherit)
{
var namespaceData = new NamespaceData(interfaceToInherit.Namespace, interfaceToInherit);
var compilationEntryData = new CompilationEntryData(options.UsingNamespaces, namespaceData);
context.AddCompilationEntry(compilationEntryData);
}
return new AttributeData[] { new MetricsCollectorInterfaceAttributeData(contextName, interfacesToInherit) };
});
}
}
public static IEnumerable <Func <ITestContext, MethodParameterData> > GetPossibleVariations(ITestInterfaceGenerationOptions options)
{
var index = 0;
foreach (var parameterAttributeCombination in
options.ParameterAttributeDataBuilder.GetPossibleCombinations(options))
{
foreach (var type in options.MethodParameterTypes)
{
var values = options.ParameterValuesBuilder.GetValues(type);
foreach (var value in values)
{
index++;
var prefix = index % 2 == 0 ? "@" : "";
var aliasTypeName = index % 1 == 0 ? "AliasType" + index : null;
yield return((context) => new MethodParameterData(prefix + "param" + context.NextId(), type, value, aliasTypeName, parameterAttributeCombination(context).ToArray()));
}
}
}
}
public IEnumerable <Func <ITestContext, IEnumerable <AttributeData> > > GetPossibleCombinations(ITestInterfaceGenerationOptions options)
{
yield break;
}
public TestContext(ITestInterfaceGenerationOptions options)
{
_options = options;
}
public static IEnumerable <Func <ITestContext, InterfaceData> > GetPossibleVariations(ITestInterfaceGenerationOptions options)
{
var interfaceMethodPossibleVariations = InterfaceMethodData.GetPossibleVariations(options).ToList();
var interfaceAttributeDataCombinations = options.InterfaceAttributeDataBuilder.GetPossibleCombinations(options);
foreach (var attributeData in interfaceAttributeDataCombinations)
{
foreach (var inheritedInterfaceCount in options.InheritedInterfaceCounts)
{
var inheritedInterfaces = options.InheritanceListBuilder.GetInheritedInterfaces(options, inheritedInterfaceCount);
foreach (var methodsCount in options.InterfaceMethodsCounts)
{
Func <ITestContext, InterfaceData> CreateInterfaceDataVariation(IEnumerable <Func <ITestContext, InterfaceMethodData> > methods)
{
return(context => new InterfaceData("ITestInterface" + context.NextId() + "<TInterfaceParam1, TInterfaceParam2>", options.InterfaceNamespace, attributeData(context).ToArray(), methods.Select(_ => _.Invoke(context)).ToArray(), inheritedInterfaces(context), true));
}
if (methodsCount == 1)
{
foreach (var methods in interfaceMethodPossibleVariations
.GetPossibleCombinations(methodsCount))
{
yield return(CreateInterfaceDataVariation(methods));
}
}
else
{
var methods = interfaceMethodPossibleVariations.Take(methodsCount);
yield return(CreateInterfaceDataVariation(methods));
}
}
}
}
}
