Context StringDomainContext(bool useDefaults, int seed)
{
return(c => c
.Given("string base domain", x => TestDataDomain = configurator => configurator.UseDefaults(useDefaults).UseRandom(new DefaultRandom(seed)))
.Given("string evolutionary domain", x => EvolutionaryDomain = configurator => configurator.AddRule(new StringMarryRule()))
.Given(DataGeneratorContext())
.Given(StringInitialDataContext()));
}
/// <summary>
/// Creates a test data generator for the given domain
/// </summary>
/// <param name="testDataDomainConfiguration">the domain, containing all relevant information for the test data generation</param>
/// <returns>the final compound value provider that can be used for data generation</returns>
public static ITestDataGenerator Create(TestDataDomainConfiguration testDataDomainConfiguration = null)
{
ChainConfigurator chainConfigurator = new DomainConfigurator();
if (testDataDomainConfiguration != null)
{
chainConfigurator = (ChainConfigurator)testDataDomainConfiguration((DomainConfigurator)chainConfigurator);
}
return(chainConfigurator.Build());
}
Context BaseContext(int seed)
{
return
(c => c
.Given("Empty domain with attribute based value provider", x =>
TestDataDomainConfiguration = (context => context
.UseDefaults(false)
.UseRandom(new DefaultRandom(seed))
.For <ClassWithMultipleAttributes>().AddProvider(new DefaultInstanceValueProvider <ClassWithMultipleAttributes>())
.For <ClassWithMultipleAttributes>().Select(cwma => cwma.Country).AddProvider(new CountryCityProvider())))
.Given("TestDataGenerator", x => TestDataGenerator = TestDataGeneratorFactory.Create(TestDataDomainConfiguration)));
}
Context BaseContext(int seed)
{
return
(c => c
.Given("Empty domain with date range value provider", x =>
TestDataDomainConfiguration = (context => context
.UseDefaults(false)
.UseRandom(new DefaultRandom(seed))
.For <ClassWithDateRange>().AddProvider(new DefaultInstanceValueProvider <ClassWithDateRange>())
.For <ClassWithDateRange>().Select(cwdr => cwdr.BirthDate).AddProvider(new DateGenerator())))
.Given("TestDataGenerator", x => TestDataGenerator = TestDataGeneratorFactory.Create(TestDataDomainConfiguration)));
}
Context BaseContext()
{
return
(c => c
.Given("{0,2,1}", x => InputList = new List <int> {
0, 2, 1
})
.Given("Empty domain with value provider", x =>
TestDataDomainConfiguration = (context => context
.UseDefaults(false)
.UseRandom(Random)
.For <string> ().AddProvider(new ChooseSingleItemValueProvider <int, string> (InputList, item => item.ToString()))))
.Given("TestDataGenerator", x => TestDataGenerator = TestDataGeneratorFactory.Create(TestDataDomainConfiguration)));
}
/// <summary>
/// Creates an evolutionary data generator for the given domain
/// </summary>
/// <param name="testDataDomainConfiguration">the domain, containing all relevant imformation for the test data generation</param>
/// <param name="evolutionaryDomainConfiguration">the domain, containing all relevant information for the evolutionary generation</param>
/// <returns>the final test data generator that can be used for data generation</returns>
public static RuleBasedDataGenerator Create(TestDataDomainConfiguration testDataDomainConfiguration, [CanBeNull] EvolutionaryDomainConfiguration evolutionaryDomainConfiguration)
{
var testDataGenerator = TestDataGeneratorFactory.Create(testDataDomainConfiguration);
var evolutionaryDomainConfigurator = new RuleBasedDataGeneratorConfigurator();
if (evolutionaryDomainConfiguration != null)
{
evolutionaryDomainConfigurator = (RuleBasedDataGeneratorConfigurator)evolutionaryDomainConfiguration(evolutionaryDomainConfigurator);
}
var ruleSet = evolutionaryDomainConfigurator.Build();
return(new RuleBasedDataGenerator(testDataGenerator, ruleSet));
}
Context PersonDomainContext(int seed = 0, bool useDefaults = true)
{
return(c => c
.Given("person test domain", x => TestDataDomain = configurator => configurator
//
.UseDefaults(useDefaults).UseRandom(new DefaultRandom(seed))
//
.For <Gender> ().AddProvider(context => (Gender)(context.Random.Next(0, 2))))
.Given("person evolution domain", x => EvolutionaryDomain = configurator => configurator
//
.AddGlobalRule(new WorldRule())
.AddRule(new ProcreationRule()).AddRule(new AgingRule()))
.Given(DataGeneratorContext())
.Given(PersonInitialDataContext()));
}
Context BaseContext()
{
return
(c =>
c
.Given("{0,1,2,3}", x => InputList = new List <int> {
0, 1, 2, 3
})
.Given("min: 2", x => MinItems = 2)
.Given("max: 4", x => MaxItems = 4)
.Given("Empty domain with value provider",
x =>
TestDataDomainConfiguration =
(context =>
context.UseDefaults(false)
.UseRandom(Random)
.For <IList <string> > ()
.AddProvider(new ChooseMultipleDistinctItemsValueProvider <int, string> (InputList, MinItems, MaxItems,
conversionFunc: item => item.ToString()))))
.Given("TestDataGenerator", x => TestDataGenerator = TestDataGeneratorFactory.Create(TestDataDomainConfiguration)));
}
Context ConfigurationContext(TestDataDomainConfiguration config)
{
return(c => c
.Given("domain with invalid configuration", x => { TestDataDomainConfiguration = config; })
.Given(TestDataGeneratorContext(catchExceptions: true)));
}
Context ConfigurationContext(TestDataDomainConfiguration config)
{
return(c => c
.Given("domain with valid configuration", x => { TestDataDomainConfiguration = config; })
.Given(TestDataGeneratorContext()));
}
