public override ITestCase[] CreateTests(ITestFixture fixture, MethodInfo method)
{
ArrayList testList = new ArrayList();
ParameterInfo[] parameters = method.GetParameters();
// create the models
DomainCollection domains = new DomainCollection();
Type[] parameterTypes = new Type[parameters.Length];
int index = 0;
foreach (ParameterInfo parameter in parameters)
{
parameterTypes[index] = parameter.ParameterType;
DomainCollection pdomains = new DomainCollection();
foreach (UsingBaseAttribute usingAttribute in parameter.GetCustomAttributes(typeof(UsingBaseAttribute), true))
{
try
{
usingAttribute.GetDomains(pdomains, parameter, fixture);
}
catch (Exception ex)
{
throw new Exception("Failed while loading domains from parameter " + parameter.Name,
ex);
}
}
if (pdomains.Count == 0)
{
throw new Exception("Could not find domain for argument " + parameter.Name);
}
domains.Add(Domains.ToDomain(pdomains));
index++;
}
// we make a cartesian product of all those
foreach (ITuple tuple in Products.Cartesian(domains))
{
// create data domains
DomainCollection tdomains = new DomainCollection();
for (int i = 0; i < tuple.Count; ++i)
{
IDomain dm = (IDomain)tuple[i];
tdomains.Add(dm);
}
// computing the pairwize product
foreach (ITuple ptuple in GetProduct(tdomains))
{
ITestCase test = new MethodTestCase(fixture.Name, method, ptuple.ToObjectArray());
testList.Add(test);
}
}
return (ITestCase[])testList.ToArray(typeof(ITestCase));
}
public static IDomainCollection ExtractBoundaries(IDomainCollection domains)
{
CheckDomains(domains);
DomainCollection boundaries = new DomainCollection();
foreach (IDomain domain in domains)
boundaries.Add(domain.Boundary);
return boundaries;
}
public static IDomainCollection Uniformize(IDomainCollection domains)
{
if (domains == null)
{
throw new ArgumentNullException("domains");
}
Random rnd = new Random((int)DateTime.Now.Ticks);
// find max
int maxCount = int.MinValue;
int minCount = int.MaxValue;
foreach (IDomain domain in domains)
{
maxCount = Math.Max(maxCount, domain.Count);
minCount = Math.Max(minCount, domain.Count);
}
if (minCount == maxCount)
{
return(domains);
}
DomainCollection udomains = new DomainCollection();
foreach (IDomain domain in domains)
{
if (domain.Count == maxCount)
{
udomains.Add(domain);
continue;
}
Object[] udomain = new Object[maxCount];
int i;
for (i = 0; i < domain.Count; ++i)
{
udomain[i] = domain[i];
}
for (; i < maxCount; ++i)
{
udomain[i] = domain[rnd.Next(domain.Count)];
}
udomains.Add(Domains.ToDomain(udomain));
}
return(udomains);
}
private void TestProblem(int k, int l)
{
// create domains
DomainCollection domains = new DomainCollection();
for (int i = 0; i < k; ++i)
{
int[] domain = new int[l];
for (int j = 0; j < l; ++j)
{
domain[j] = j;
}
domains.Add(Domains.ToDomain(domain));
}
// iterface
ITupleEnumerable tuples = Products.PairWize(domains);
int f = 1;
foreach (ITuple tuple in tuples)
{
Console.WriteLine("{0}: {1}", f++, tuple);
}
}
public static IDomainCollection Uniformize(IDomainCollection domains)
{
if (domains == null)
throw new ArgumentNullException("domains");
Random rnd = new Random((int)DateTime.Now.Ticks);
// find max
int maxCount = int.MinValue;
int minCount = int.MaxValue;
foreach (IDomain domain in domains)
{
maxCount = Math.Max(maxCount, domain.Count);
minCount = Math.Max(minCount, domain.Count);
}
if (minCount == maxCount)
return domains;
DomainCollection udomains = new DomainCollection();
foreach (IDomain domain in domains)
{
if (domain.Count == maxCount)
{
udomains.Add(domain);
continue;
}
Object[] udomain = new Object[maxCount];
int i;
for(i = 0;i<domain.Count;++i)
udomain[i] = domain[i];
for (; i<maxCount;++i)
{
udomain[i] = domain[ rnd.Next(domain.Count) ];
}
udomains.Add(Domains.ToDomain(udomain));
}
return udomains;
}
public static IDomainCollection ToDomains(params Object[] items)
{
if (items.Length == 0)
throw new ArgumentException("Length is zero", "items");
DomainCollection ds = new DomainCollection();
foreach (Object domain in items)
ds.Add(ToDomain(domain));
return ds;
}
private void ReflectTestMethod(
RunInvokerTree tree,
RunInvokerVertex parent,
object fixture,
MethodInfo method,
IgnoreAttribute ignore)
{
// Check if fixture or method is ignored
if (ignore == null && TypeHelper.HasCustomAttribute(method, typeof(IgnoreAttribute)))
{
ignore = TypeHelper.GetFirstCustomAttribute(method, typeof(IgnoreAttribute)) as IgnoreAttribute;
}
if (ignore != null)
{
// Do not generate unnecessary test cases
IgnoredLoadingRunInvoker invoker = new IgnoredLoadingRunInvoker(this, method, ignore.Description);
tree.AddChild(parent, invoker);
}
else
{
CombinatorialTestAttribute testAttribute = TypeHelper.GetFirstCustomAttribute(method, typeof(CombinatorialTestAttribute))
as CombinatorialTestAttribute;
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length == 0)
{
Exception ex = new Exception("No parameters");
MethodFailedLoadingRunInvoker invoker = new MethodFailedLoadingRunInvoker(this, ex, method);
tree.AddChild(parent, invoker);
return;
}
// create the models
DomainCollection domains = new DomainCollection();
Type[] parameterTypes = new Type[parameters.Length];
int index = 0;
foreach (ParameterInfo parameter in parameters)
{
parameterTypes[index] = parameter.ParameterType;
DomainCollection pdomains = new DomainCollection();
foreach (UsingBaseAttribute usingAttribute in parameter.GetCustomAttributes(typeof(UsingBaseAttribute), true))
{
try
{
usingAttribute.GetDomains(pdomains, parameter, fixture);
}
catch (Exception ex)
{
Exception pex = new Exception("Failed while loading domains from parameter " + parameter.Name,
ex);
MethodFailedLoadingRunInvoker invoker = new MethodFailedLoadingRunInvoker(this, pex, method);
tree.AddChild(parent, invoker);
}
}
if (pdomains.Count == 0)
{
Exception ex = new Exception("Could not find domain for argument " + parameter.Name);
MethodFailedLoadingRunInvoker invoker = new MethodFailedLoadingRunInvoker(this, ex, method);
tree.AddChild(parent, invoker);
return;
}
domains.Add(Domains.ToDomain(pdomains));
index++;
}
// get the validator method if any
MethodInfo validator = null;
if (testAttribute.TupleValidatorMethod != null)
{
validator = fixture.GetType().GetMethod(testAttribute.TupleValidatorMethod, parameterTypes);
if (validator == null)
{
Exception ex = new Exception("Could not find validator method " + testAttribute.TupleValidatorMethod);
MethodFailedLoadingRunInvoker invoker = new MethodFailedLoadingRunInvoker(this, ex, method);
tree.AddChild(parent, invoker);
return;
}
}
// we make a cartesian product of all those
foreach (ITuple tuple in Products.Cartesian(domains))
{
// create data domains
DomainCollection tdomains = new DomainCollection();
for (int i = 0; i < tuple.Count; ++i)
{
IDomain dm = (IDomain)tuple[i];
tdomains.Add(dm);
}
// computing the pairwize product
foreach (ITuple ptuple in testAttribute.GetProduct(tdomains))
{
if (validator != null)
{
bool isValid = (bool)validator.Invoke(fixture, ptuple.ToObjectArray());
if (!isValid)
continue;
}
TupleRunInvoker invoker = new TupleRunInvoker(this, method, tuple, ptuple);
IRunInvoker dinvoker = DecoratorPatternAttribute.DecoreInvoker(method, invoker);
tree.AddChild(parent, dinvoker);
}
}
}
}
private void TestProblem(int k, int l)
{
// create domains
DomainCollection domains = new DomainCollection();
for (int i = 0; i < k; ++i)
{
int[] domain = new int[l];
for (int j = 0; j < l; ++j)
domain[j] = j;
domains.Add(Domains.ToDomain(domain));
}
// iterface
ITupleEnumerable tuples = Products.PairWize(domains);
int f = 1;
foreach (ITuple tuple in tuples)
{
Console.WriteLine("{0}: {1}",f++,tuple);
}
}
