public static ITupleEnumerable TWize(int tupleSize, IDomainCollection domains)
{
CheckDomains(domains);
IDomainCollection udomains = Domains.Uniformize(domains);
return new UniformTWizeProductDomainTupleEnumerable(udomains, tupleSize);
}
/// <summary>
/// Gets the set of values (the collection of domains) for the parameter.
/// </summary>
/// <param name="domains">The <see cref="IDomainCollection"/> the values generated by the source of data</param>
/// <param name="parameter"><see cref="ParameterInfo"/> for the parameter that wants the values.</param>
/// <param name="fixture">The test fixture.</param>
/// <remarks>See <a href="http://blog.dotnetwiki.org/CombinatorialTestingWithTestFu1.aspx">here</a> for more on
/// domain generation</remarks>
public override void GetDomains(IDomainCollection domains, ParameterInfo parameter, object fixture)
{
bool isString = parameter.ParameterType.IsAssignableFrom(typeof(string));
ArrayList data = new ArrayList();
foreach (string memberName in this.Values.Split(';'))
{
object cresult = null;
if (isString)
{
cresult = memberName.ToString();
}
else
{
cresult = Convert.ChangeType(memberName, parameter.ParameterType);
}
data.Add(cresult);
}
if (data.Count == 0)
{
return;
}
CollectionDomain domain = new CollectionDomain(data);
domains.Add(domain);
}
public UniformTWizeProductDomainTupleEnumerable(IDomainCollection domains, int tupleSize)
{
if (domains == null)
{
throw new ArgumentNullException("domains");
}
if (tupleSize <= 0)
{
throw new ArgumentOutOfRangeException("tupleSize is negative or zero");
}
this.domains = domains;
this.tupleSize = tupleSize;
int count = -1;
for (int i = 0; i < domains.Count; ++i)
{
if (i == 0)
{
count = domains[i].Count;
}
else
{
if (count != domains[i].Count)
{
throw new ArgumentException("Domains have not uniform size");
}
}
}
}
/// <summary>
/// Gets the set of values (the collection of domains) for the parameter.
/// </summary>
/// <param name="domains">The <see cref="IDomainCollection"/> the values generated by the source of data</param>
/// <param name="parameter"><see cref="ParameterInfo"/> for the parameter that wants the values.</param>
/// <param name="fixture">The test fixture.</param>
/// <remarks>See <a href="http://blog.dotnetwiki.org/CombinatorialTestingWithTestFu1.aspx">here</a> for more on
/// domain generation</remarks>
public override void GetDomains(
IDomainCollection domains,
ParameterInfo parameter,
object fixture) {
ArrayDomain domain = new ArrayDomain(Enum.GetValues(this.EnumType));
domains.Add(domain);
}
/// <summary>
/// Gets the set of values (the collection of domains) for the parameter.
/// </summary>
/// <param name="domains">The <see cref="IDomainCollection"/> the values generated by the source of data</param>
/// <param name="parameter"><see cref="ParameterInfo"/> for the parameter that wants the values.</param>
/// <param name="fixture">The test fixture.</param>
/// <remarks>See <a href="http://blog.dotnetwiki.org/CombinatorialTestingWithTestFu1.aspx">here</a> for more on
/// domain generation</remarks>
public override void GetDomains(IDomainCollection domains, ParameterInfo parameter, object fixture)
{
ArrayList types = new ArrayList();
foreach (Type type in typeFromAssembly.Assembly.GetExportedTypes())
{
if (type.IsAbstract || type.IsInterface || !type.IsClass)
{
continue;
}
if (!parameter.ParameterType.IsAssignableFrom(type))
{
continue;
}
// create instance
Object instance = TypeHelper.CreateInstance(type);
types.Add(instance);
}
CollectionDomain domain = new CollectionDomain(types);
domain.Name = typeFromAssembly.Assembly.GetName().Name;
domains.Add(domain);
}
public ReportEndTermDividWep(ReportingPeriodDetail reportPeriod, IList<IEndTermValue> endTermValues)
{
this.records = new EndTermDividWepComparisonCollection(this);
this.ReportPeriod = reportPeriod;
this.EndtermValues = endTermValues;
createList();
}
public static ITupleEnumerable TWize(int tupleSize, IDomainCollection domains)
{
CheckDomains(domains);
IDomainCollection udomains = Domains.Uniformize(domains);
return(new UniformTWizeProductDomainTupleEnumerable(udomains, tupleSize));
}
public PairWizeProductDomainTupleEnumerable(IDomainCollection domains)
{
if (domains == null)
{
throw new ArgumentNullException("domains");
}
this.domains = domains;
}
public void DomainCountMistmatch()
{
int[] array1 = new int[] { 1, 2 };
int[] array2 = new int[] { 1, 2, 3 };
IDomainCollection dom = Domains.ToDomains(array1, array2);
new UniformPairWizeProductDomainTupleEnumerable(dom);
}
/// <summary>
/// Gets the set of values (the collection of domains) for the parameter.
/// </summary>
/// <param name="domains">The <see cref="IDomainCollection"/> the values generated by the source of data</param>
/// <param name="parameter"><see cref="ParameterInfo"/> for the parameter that wants the values.</param>
/// <param name="fixture">The test fixture.</param>
/// <remarks>See <a href="http://blog.dotnetwiki.org/CombinatorialTestingWithTestFu1.aspx">here</a> for more on
/// domain generation</remarks>
public override void GetDomains(
IDomainCollection domains,
ParameterInfo parameter,
object fixture)
{
ArrayDomain domain = new ArrayDomain(Enum.GetValues(this.EnumType));
domains.Add(domain);
}
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 void ClassInit(TestContext context)
{
app = new CremaBootstrapper();
app.Initialize(context, nameof(IDomainCollection_DispatcherTest));
cremaHost = app.GetService(typeof(ICremaHost)) as ICremaHost;
cremaHost.Dispatcher.Invoke(() =>
{
authentication = cremaHost.Start();
domains = cremaHost.GetService(typeof(IDomainCollection)) as IDomainCollection;
});
}
public DomainTupleEnumeratorBase(IDomainCollection domains)
{
if (domains == null)
throw new ArgumentNullException("domains");
this.domains = domains;
foreach(IDomain domain in domains)
{
if (domain.Count == 0)
throw new ArgumentException("A domain is empty");
}
}
public static IDomainCollection ExtractBoundaries(IDomainCollection domains)
{
CheckDomains(domains);
DomainCollection boundaries = new DomainCollection();
foreach (IDomain domain in domains)
{
boundaries.Add(domain.Boundary);
}
return(boundaries);
}
public void UniformizeUniform()
{
int[] array1 = new int[] { 1, 2 };
int[] array2 = new int[] { 1, 2 };
IDomainCollection domains = Domains.Uniformize(array1, array2);
foreach (IDomain domain in domains)
{
Assert.AreEqual(domain.Count, 2);
}
}
public void UniformizeNonUniform()
{
int[] array1 = new int[] { 1, 2 };
int[] array2 = new int[] { 1, 2, 3, 4 };
int[] array3 = new int[] { 1, 2, 3, 4, 5, 6, 7 };
IDomainCollection domains = Domains.Uniformize(array1, array2, array3);
foreach (IDomain domain in domains)
{
Assert.AreEqual(domain.Count, 7);
}
}
public static ITupleEnumerable PairWize(IDomainCollection domains)
{
CheckDomains(domains);
if (domains.Count <= 2)
return Cartesian(domains);
if (Domains.IsUniform(domains))
return new UniformPairWizeProductDomainTupleEnumerable(domains);
else
{
IDomainCollection udomains = Domains.Uniformize(domains);
return Greedy(new UniformPairWizeProductDomainTupleEnumerable(udomains));
}
}
/// <summary>
/// Returns the object representing the set of all tuples to be tested.
/// </summary>
/// <param name="domains">The collection of sets of parameter values to be combined</param>
/// <returns>An <see cref="ITupleEnumerable"/> object representing the set of tuples to be tested</returns>
public ITupleEnumerable GetProduct(IDomainCollection domains)
{
switch (this.CombinationType)
{
case CombinationType.AllPairs:
return(Products.PairWize(domains));
case CombinationType.Cartesian:
return(Products.Cartesian(domains));
default:
throw new NotSupportedException();
}
}
private void GetAllDomains(IDomainCollection domains, ParameterInfo parameter, Type t)
{
foreach (MethodInfo factoryMethod in TypeHelper.GetAttributedMethods(t, typeof(FactoryAttribute)))
{
if (factoryMethod.GetParameters().Length > 0)
{
continue;
}
Type returnType = factoryMethod.ReturnType;
// check single object return
if (parameter.ParameterType.IsAssignableFrom(returnType))
{
object result = this.InvokeMethod(t, factoryMethod);
IDomain domain = Domains.ToDomain(result);
domain.Name = factoryMethod.Name;
domains.Add(domain);
continue;
}
// check array
if (returnType.HasElementType)
{
Type elementType = returnType.GetElementType();
if (parameter.ParameterType == elementType)
{
object result = this.InvokeMethod(t, factoryMethod);
IDomain domain = Domains.ToDomain(result);
domain.Name = factoryMethod.Name;
domains.Add(domain);
continue;
}
}
// check factory type
FactoryAttribute factoryAttribute = TypeHelper.TryGetFirstCustomAttribute(factoryMethod, typeof(FactoryAttribute)) as FactoryAttribute;
if (factoryAttribute != null)
{
Type factoredType = factoryAttribute.FactoredType;
if (parameter.ParameterType == factoredType)
{
object result = this.InvokeMethod(t, factoryMethod);
IDomain domain = Domains.ToDomain(result);
domain.Name = factoryMethod.Name;
domains.Add(domain);
continue;
}
}
}
}
public DomainTupleEnumeratorBase(IDomainCollection domains)
{
if (domains == null)
{
throw new ArgumentNullException("domains");
}
this.domains = domains;
foreach (IDomain domain in domains)
{
if (domain.Count == 0)
{
throw new ArgumentException("A domain is empty");
}
}
}
public static bool IsUniform(IDomainCollection domains)
{
if (domains == null)
throw new ArgumentNullException("domains");
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 (maxCount != minCount)
return false;
}
return true;
}
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 ITupleEnumerable PairWize(IDomainCollection domains)
{
CheckDomains(domains);
if (domains.Count <= 2)
{
return(Cartesian(domains));
}
if (Domains.IsUniform(domains))
{
return(new UniformPairWizeProductDomainTupleEnumerable(domains));
}
else
{
IDomainCollection udomains = Domains.Uniformize(domains);
return(Greedy(new UniformPairWizeProductDomainTupleEnumerable(udomains)));
}
}
private void GetNamedDomains(IDomainCollection domains, ParameterInfo parameter, Type t)
{
foreach (string memberName in this.MemberNames.Split(';'))
{
MethodInfo domainMethod = t.GetMethod(memberName, Type.EmptyTypes);
if (domainMethod == null)
{
Assert.Fail("Could not find domain method {0} for parameter {1}",
memberName, parameter.Name);
}
object result = this.InvokeMethod(t, domainMethod);
IDomain domain = Domains.ToDomain(result);
domain.Name = domainMethod.Name;
domains.Add(domain);
}
}
/// <summary>
/// Gets the set of values (the collection of domains) for the parameter.
/// </summary>
/// <param name="domains">The <see cref="IDomainCollection"/> the values generated by the source of data</param>
/// <param name="parameter"><see cref="ParameterInfo"/> for the parameter that wants the values.</param>
/// <param name="fixture">The test fixture.</param>
/// <remarks>See <a href="http://blog.dotnetwiki.org/CombinatorialTestingWithTestFu1.aspx">here</a> for more on
/// domain generation</remarks>
public override void GetDomains(IDomainCollection domains, ParameterInfo parameter, object fixture) {
ArrayList types = new ArrayList();
foreach (Type type in typeFromAssembly.Assembly.GetExportedTypes()) {
if (type.IsAbstract || type.IsInterface || !type.IsClass)
continue;
if (!parameter.ParameterType.IsAssignableFrom(type))
continue;
// create instance
Object instance = TypeHelper.CreateInstance(type);
types.Add(instance);
}
CollectionDomain domain = new CollectionDomain(types);
domain.Name = typeFromAssembly.Assembly.GetName().Name;
domains.Add(domain);
}
public override void GetDomains(IDomainCollection domains, ParameterInfo parameter, object fixture)
{
bool isString = parameter.ParameterType.IsAssignableFrom(typeof(string));
ArrayList data = new ArrayList();
foreach (string memberName in this.Values.Split(';'))
{
object cresult = null;
if (isString)
cresult = memberName.ToString();
else
cresult = Convert.ChangeType(memberName, parameter.ParameterType);
data.Add(cresult);
}
if (data.Count == 0)
return;
CollectionDomain domain = new CollectionDomain(data);
domains.Add(domain);
}
public static bool IsUniform(IDomainCollection domains)
{
if (domains == null)
{
throw new ArgumentNullException("domains");
}
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 (maxCount != minCount)
{
return(false);
}
}
return(true);
}
public UniformTWizeProductDomainTupleEnumerable(IDomainCollection domains, int tupleSize)
{
if (domains == null)
throw new ArgumentNullException("domains");
if (tupleSize <= 0)
throw new ArgumentOutOfRangeException("tupleSize is negative or zero");
this.domains = domains;
this.tupleSize = tupleSize;
int count = -1;
for (int i = 0; i < domains.Count; ++i)
{
if (i == 0)
count = domains[i].Count;
else
{
if (count != domains[i].Count)
throw new ArgumentException("Domains have not uniform size");
}
}
}
private static void CheckDomains(IDomainCollection domains)
{
if (domains == null)
{
throw new ArgumentNullException("domains");
}
if (domains.Count == 0)
{
throw new ArgumentException("domains is empty");
}
for (int i = 0; i < domains.Count; ++i)
{
if (domains[i] == null)
{
throw new ArgumentNullException("Domain[" + i.ToString() + "] is null");
}
if (domains[i].Count == 0)
{
throw new ArgumentNullException("Domain[" + i.ToString() + "] is empty");
}
}
}
/// <summary>
/// Gets the set of values (the collection of domains) for the parameter.
/// </summary>
/// <param name="domains">The <see cref="IDomainCollection"/> the values generated by the source of data</param>
/// <param name="parameter"><see cref="ParameterInfo"/> for the parameter that wants the values.</param>
/// <param name="fixture">The test fixture.</param>
/// <remarks>See <a href="http://blog.dotnetwiki.org/CombinatorialTestingWithTestFu1.aspx">here</a> for more on
/// domain generation</remarks>
public override void GetDomains(IDomainCollection domains, ParameterInfo parameter, object fixture)
{
Type t = null;
if (this.factoryType != null)
{
t = factoryType;
}
else
{
t = parameter.Member.DeclaringType;
}
if (this.MemberNames == null)
{
GetAllDomains(domains, parameter, t);
}
else
{
GetNamedDomains(domains, parameter, t);
}
}
public UniformPairWizeProductDomainTupleEnumerable(IDomainCollection domains)
{
if (domains == null)
{
throw new ArgumentNullException("domains");
}
this.domains = domains;
int count = -1;
for (int i = 0; i < domains.Count; ++i)
{
if (i == 0)
{
count = domains[i].Count;
}
else
{
if (count != domains[i].Count)
{
throw new ArgumentException("Domains have not uniform size");
}
}
}
}
public static Task <bool> ContainsAsync(this IDomainCollection domains, Guid domainID)
{
return(domains.Dispatcher.InvokeAsync(() => domains.Contains(domainID)));
}
public void ConstructWithNullDomains()
{
IDomainCollection domains = null;
Products.PairWize(domains);
}
public static ITupleEnumerable Cartesian(IDomainCollection domains)
{
CheckDomains(domains);
return new CartesianProductDomainTupleEnumerable(domains);
}
public BookingComponent()
{
journalLines = new BookingLineCollection(this);
}
public PairWizeProductDomainTupleEnumerator(IDomainCollection domains)
: base(domains)
{
this.Reset();
}
public UniformTWizeProductDomainTupleEnumerator(IDomainCollection domains, int tupleSize)
: base(domains)
{
this.tupleSize = tupleSize;
this.CreateColoring();
}
public void UniformizeWithNull()
{
IDomainCollection domains = null;
Domains.Uniformize(domains);
}
public ExportedLedgerFile()
{
ledgerEntries = new LedgerEntryCollection(this);
}
public CartesianProductDomainTupleEnumerable(IDomainCollection domains)
{
this.domains = domains;
}
public override void GetDomains(IDomainCollection domains, ParameterInfo parameter, object fixture)
{
domains.Add(domain);
}
public CashPosition()
{
this.CreationDate = DateTime.Now;
unSettledPositions = new CashSubPositionUnSettledCollection(this);
}
private ITupleEnumerable GetProduct(IDomainCollection domains)
{
switch (this.CombinationType)
{
case CombinationType.AllPairs:
return Products.PairWize(domains);
case CombinationType.Cartesian:
return Products.Cartesian(domains);
default:
throw new NotSupportedException();
}
}
/// <summary>
/// Gets the set of values (the collection of domains) for the parameter.
/// </summary>
/// <remarks>See <a href="http://blog.dotnetwiki.org/CombinatorialTestingWithTestFu1.aspx">here</a> for more on
/// domain generation</remarks>
/// <param name="domains">The <see cref="IDomainCollection"/> the values generated by the source of data</param>
/// <param name="parameter"><see cref="ParameterInfo"/> for the parameter that wants the values.</param>
/// <param name="fixture">The test fixture.</param>
public abstract void GetDomains(IDomainCollection domains, ParameterInfo parameter,
object fixture);
public PositionTransferReportPortfolio()
{
this.positions = new PositionTransferReportPositionCollection(this);
}
private void GetNamedDomains(IDomainCollection domains, ParameterInfo parameter, Type t)
{
foreach (string memberName in this.MemberNames.Split(';'))
{
MethodInfo domainMethod = t.GetMethod(memberName, Type.EmptyTypes);
if (domainMethod == null)
Assert.Fail("Could not find domain method {0} for parameter {1}",
memberName, parameter.Name);
object result = this.InvokeMethod(t, domainMethod);
IDomain domain = Domains.ToDomain(result);
domain.Name = domainMethod.Name;
domains.Add(domain);
}
}
private static void CheckDomains(IDomainCollection domains)
{
if (domains == null)
throw new ArgumentNullException("domains");
if (domains.Count == 0)
throw new ArgumentException("domains is empty");
for (int i = 0; i < domains.Count; ++i)
{
if (domains[i] == null)
throw new ArgumentNullException("Domain[" + i.ToString() + "] is null");
if (domains[i].Count==0)
throw new ArgumentNullException("Domain[" + i.ToString() + "] is empty");
}
}
internal CashSubPosition()
{
journalLines = new GLJournalEntryLineCollection(this);
}
private void GetAllDomains(IDomainCollection domains, ParameterInfo parameter, Type t)
{
foreach (MethodInfo factoryMethod in TypeHelper.GetAttributedMethods(t, typeof(FactoryAttribute)))
{
if (factoryMethod.GetParameters().Length > 0)
continue;
Type returnType = factoryMethod.ReturnType;
// check single object return
if (parameter.ParameterType.IsAssignableFrom(returnType))
{
object result = this.InvokeMethod(t, factoryMethod);
IDomain domain = Domains.ToDomain(result);
domain.Name = factoryMethod.Name;
domains.Add(domain);
continue;
}
// check array
if (returnType.HasElementType)
{
Type elementType = returnType.GetElementType();
if (parameter.ParameterType == elementType)
{
object result = this.InvokeMethod(t, factoryMethod);
IDomain domain = Domains.ToDomain(result);
domain.Name = factoryMethod.Name;
domains.Add(domain);
continue;
}
}
// check factory type
FactoryAttribute factoryAttribute = TypeHelper.TryGetFirstCustomAttribute(factoryMethod, typeof(FactoryAttribute)) as FactoryAttribute;
if (factoryAttribute != null)
{
Type factoredType = factoryAttribute.FactoredType;
if (parameter.ParameterType == factoredType)
{
object result = this.InvokeMethod(t, factoryMethod);
IDomain domain = Domains.ToDomain(result);
domain.Name = factoryMethod.Name;
domains.Add(domain);
continue;
}
}
}
}
public PositionTransfer()
{
this.transferDetails = new PositionTransferDetailCollection(this);
//this.CreatedBy = B4F.TotalGiro.Security.SecurityManager.CurrentUser;
}
public override void GetDomains(IDomainCollection domains, ParameterInfo parameter, object fixture)
{
Type t = null;
if (this.factoryType != null)
t = factoryType;
else
t = parameter.Member.DeclaringType;
if (this.MemberNames == null)
{
GetAllDomains(domains, parameter, t);
}
else
{
GetNamedDomains(domains, parameter, t);
}
}
/// <summary>
/// Gets the set of values (the collection of domains) for the parameter.
/// </summary>
/// <remarks>See <a href="http://blog.dotnetwiki.org/CombinatorialTestingWithTestFu1.aspx">here</a> for more on
/// domain generation</remarks>
/// <param name="domains">The <see cref="IDomainCollection"/> the values generated by the source of data</param>
/// <param name="parameter"><see cref="ParameterInfo"/> for the parameter that wants the values.</param>
/// <param name="fixture">The test fixture.</param>
public abstract void GetDomains(IDomainCollection domains, ParameterInfo parameter,
object fixture);
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 LedgerEntry()
{
exactFormatter = new ExactFormatter(this);
subLedgerEntries = new SubledgerEntryCollection(this);
}
public CartesianProductDomainTupleEnumerator(IDomainCollection domains)
: base(domains)
{
this.indices=new int[this.Domains.Count];
this.Reset();
}
public CartesianProductDomainTupleEnumerator(IDomainCollection domains)
: base(domains)
{
this.indices = new int[this.Domains.Count];
this.Reset();
}
public PairWizeProductDomainTupleEnumerable(IDomainCollection domains)
{
if (domains==null)
throw new ArgumentNullException("domains");
this.domains = domains;
}
public static ITupleEnumerable Cartesian(IDomainCollection domains)
{
CheckDomains(domains);
return(new CartesianProductDomainTupleEnumerable(domains));
}
public Portfolio()
{
glpositions = new CashPortfolio(this.ParentAccount);
instrumentPositions = new FundPortfolio(this.ParentAccount);
}
/// <summary>
/// Gets the set of values (the collection of domains) for the parameter.
/// </summary>
/// <param name="domains">The <see cref="IDomainCollection"/> the values generated by the source of data</param>
/// <param name="parameter"><see cref="ParameterInfo"/> for the parameter that wants the values.</param>
/// <param name="fixture">The test fixture.</param>
/// <remarks>See <a href="http://blog.dotnetwiki.org/CombinatorialTestingWithTestFu1.aspx">here</a> for more on
/// domain generation</remarks>
public override void GetDomains(IDomainCollection domains, ParameterInfo parameter, object fixture)
{
domains.Add(domain);
}
