@Test
public void testCreateGenerator_int() {
LiteralSequence sequence = new LiteralSequence("2, 3, 5, 7, 11");
Generator<Integer> generator = sequence.createNumberGenerator(Integer.class, 1, 20, 1, false);
generator.init(context);
expectGeneratedSequence(generator, 2, 3, 5, 7, 11);
}
@Test
public void testSyntheticGeneration() {
// given an array descriptor
ArrayTypeDescriptor arrayDescriptor = createArrayType("");
ArrayElementDescriptor e1 = createArrayElement(0, "string");
((SimpleTypeDescriptor) e1.getLocalType(false)).setValues("'Alice', 'Bob'");
arrayDescriptor.addElement(e1);
ArrayElementDescriptor e2 = createArrayElement(1, "int");
((SimpleTypeDescriptor) e2.getLocalType(false)).setValues("23,34");
arrayDescriptor.addElement(e2);
// when creating a generator for the descriptor
Generator<Object[]> generator =
(Generator<Object[]>)
arrayTypeGeneratorFactory.createGenerator(
arrayDescriptor, "testSyntheticGeneration", false, Uniqueness.NONE, context);
// it is expected to generate as specified
generator.init(context);
for (int i = 0; i < 10; i++) {
Object[] product = GeneratorUtil.generateNonNull(generator);
assertNotNull(product);
assertTrue(
"Expected 'Alice' or 'Bob', but was: " + product[0],
"Alice".equals(product[0]) || "Bob".equals(product[0]));
assertTrue((Integer) product[1] == 23 || (Integer) product[1] == 34);
}
}
@SuppressWarnings({"unchecked", "rawtypes"})
protected <T> void expectUniqueSet(PartDescriptor name, T... products) {
ComponentBuilder builder = createComponentBuilder(name);
Generator<T> helper = new ComponentBuilderGenerator(builder, name.getName());
helper.init(context);
expectUniquelyGeneratedSet(helper, products).withCeasedAvailability();
}
@SuppressWarnings({"unchecked", "rawtypes"})
protected <T> void expectSet(PartDescriptor name, int n, T... products) {
ComponentBuilder builder = createComponentBuilder(name);
Generator<T> helper = new ComponentBuilderGenerator(builder, name.getName());
helper.init(context);
expectGeneratedSet(helper, n, products);
}
@Test
public void testUniqueValuesArrayGeneration() {
ArrayElementDescriptor e0 = createArrayElement(0, "int");
((SimpleTypeDescriptor) e0.getLocalType(false)).setValues("1,2");
ArrayElementDescriptor e1 = createArrayElement(1, "int");
((SimpleTypeDescriptor) e1.getLocalType(false)).setValues("3,4");
ArrayTypeDescriptor arrayTypeDescriptor = createArrayType("MyArray");
arrayTypeDescriptor.addElement(e0);
arrayTypeDescriptor.addElement(e1);
InstanceDescriptor arrayInstDescriptor = createInstance("array", arrayTypeDescriptor);
arrayInstDescriptor.setUnique(true);
Generator<Object[]> generator =
(Generator<Object[]>)
InstanceGeneratorFactory.createSingleInstanceGenerator(
arrayInstDescriptor, Uniqueness.NONE, context);
generator.init(context);
for (int i = 0; i < 4; i++) {
Object[] product = GeneratorUtil.generateNonNull(generator);
assertTrue(
Arrays.equals(INT13, product)
|| Arrays.equals(INT14, product)
|| Arrays.equals(INT23, product)
|| Arrays.equals(INT24, product));
}
assertUnavailable(generator);
}
/**
* TODO v0.8 implement array mutation @Test public void testMutatingGeneration() { Object[]
* MUTATED_ALICE = new Object[] { "Alice", 24 };
*
* <p>// define descriptor ArrayTypeDescriptor descriptor = createPersonDescriptor();
* descriptor.setGenerator(PersonAttrArrayGenerator.class.getName());
* descriptor.getElement(1).getLocalType(false).setScript("p[1] + 1");
*
* <p>// create generator Generator<Object[]> generator =
* ArrayGeneratorFactory.createArrayGenerator( "p", descriptor, Uniqueness.NONE, context);
* generator.init(context);
*
* <p>// validate for (int i = 0; i < 10; i++) assertEqualArrays(MUTATED_ALICE,
* GeneratorUtil.generateNonNull(generator)); }
*/
@Test
public void testUniqueArrayGeneration() {
ArrayTypeDescriptor arrayTypeDescriptor = createArrayType("MyArray");
// create descriptor
context.set("gen0", new SequenceTestGenerator<Integer>(1, 2));
ArrayElementDescriptor e0 = createArrayElement(0, "int");
((SimpleTypeDescriptor) e0.getLocalType(false)).setGenerator("gen0");
arrayTypeDescriptor.addElement(e0);
context.set("gen1", new SequenceTestGenerator<Integer>(3, 4));
ArrayElementDescriptor e1 = createArrayElement(1, "int");
((SimpleTypeDescriptor) e1.getLocalType(false)).setGenerator("gen1");
arrayTypeDescriptor.addElement(e1);
InstanceDescriptor arrayInstDescriptor = createInstance("array", arrayTypeDescriptor);
arrayInstDescriptor.setUnique(true);
// create generator
Generator<Object[]> generator =
(Generator<Object[]>)
InstanceGeneratorFactory.createSingleInstanceGenerator(
arrayInstDescriptor, Uniqueness.NONE, context);
generator.init(context);
// test generator
assertArray(INT13, GeneratorUtil.generateNonNull(generator));
assertArray(INT14, GeneratorUtil.generateNonNull(generator));
assertArray(INT23, GeneratorUtil.generateNonNull(generator));
assertArray(INT24, GeneratorUtil.generateNonNull(generator));
assertUnavailable(generator);
}
@Test
public void testApplyTo() {
SequenceGenerator<Integer> source = new SequenceGenerator<Integer>(Integer.class, 1, 2, 3);
source.init(context);
Generator<Integer> generator = createWeight().applyTo(source, false);
generator.init(context);
expectRelativeWeights(generator, 5000, 1, 1, 2, 2, 3, 3);
}
@Test
public void testApply() {
Generator<String> source = new SequenceTestGenerator<String>("A", "B", "C", "D");
LiteralSequence sequence = new LiteralSequence("1, 3");
Generator<String> generator = sequence.applyTo(source, false);
generator.init(context);
expectGeneratedSequence(generator, "B", "D");
}
@Test(expected = ConfigurationError.class)
public void testIllegalSourceType() {
ArrayTypeDescriptor descriptor = createArrayType("");
descriptor.setSource("illegalSource");
context.set("illegalSource", new File("txt.txt"));
Generator<Object[]> generator =
(Generator<Object[]>)
arrayTypeGeneratorFactory.createGenerator(
descriptor, "testIllegalSourceType", false, Uniqueness.NONE, context);
generator.init(context);
}
@Test
public void testApply_notUnique() {
Generator<String> source = new SequenceTestGenerator<String>("A", "B");
source.init(new DefaultBeneratorContext());
Generator<String> generator = fcn.applyTo(source, false);
generator.init(context);
int n = 1000;
Map<String, AtomicInteger> counts = super.countProducts(generator, n);
assertEquals(2, counts.size());
assertTrue(counts.get("A").doubleValue() > counts.get("B").doubleValue());
}
@Test
public void testGenerator() {
ArrayTypeDescriptor descriptor = createArrayType("testGenerator");
descriptor.setGenerator(PersonAttrArrayGenerator.class.getName());
Generator<Object[]> generator =
(Generator<Object[]>)
arrayTypeGeneratorFactory.createGenerator(
descriptor, "testGenerator", false, Uniqueness.NONE, context);
generator.init(context);
for (int i = 0; i < 10; i++)
assertEqualArrays(PersonAttrArrayGenerator.ALICE, GeneratorUtil.generateNonNull(generator));
}
@Test
public void testXlsSource() {
ArrayTypeDescriptor parent = createPersonDescriptor();
ArrayTypeDescriptor descriptor = createArrayType("testXlsSource", parent);
descriptor.setSource("org/databene/benerator/factory/person.ent.xls");
Generator<Object[]> generator =
(Generator<Object[]>)
arrayTypeGeneratorFactory.createGenerator(
descriptor, "testXlsSource", false, Uniqueness.NONE, context);
context.set("otto_age", 89);
generator.init(context);
expectGeneratedSequence(generator, ALICE, OTTO).withCeasedAvailability();
}
@Test
public void testGeneratorSource() {
context.set("myGen", new PersonAttrArrayGenerator());
ArrayTypeDescriptor parent = createPersonDescriptor();
ArrayTypeDescriptor descriptor = createArrayType("testGeneratorSource", parent);
descriptor.setSource("myGen");
Generator<Object[]> generator =
(Generator<Object[]>)
arrayTypeGeneratorFactory.createGenerator(
descriptor, "testGeneratorSource", false, Uniqueness.NONE, context);
generator.init(context);
for (int i = 0; i < 10; i++) assertEqualArrays(ALICE, GeneratorUtil.generateNonNull(generator));
}
@Test
public void testCreateDoubleGenerator_notUnique() {
Generator<Double> generator = fcn.createNumberGenerator(Double.class, 1., 2., 0.5, false);
generator.init(context);
int n = 2000;
Map<Double, AtomicInteger> counts = super.countProducts(generator, n);
assertEquals(3, counts.size());
int lastCount = n + 1;
for (double d = 1; d <= 2; d += 0.5) {
int count = counts.get(d).intValue();
assertTrue(count < lastCount);
lastCount = count;
}
}
@Test
public void testCsvSource() {
ArrayTypeDescriptor parent = createPersonDescriptor();
ArrayTypeDescriptor descriptor = createArrayType("testCsvSource", parent);
descriptor.setSource("org/databene/benerator/factory/person.ent.csv");
Generator<Object[]> generator =
(Generator<Object[]>)
arrayTypeGeneratorFactory.createGenerator(
descriptor, "testCsvSource", false, Uniqueness.NONE, context);
context.set("ottos_age", 89);
generator.init(context);
assertEqualArrays(ALICE, GeneratorUtil.generateNonNull(generator));
assertEqualArrays(OTTO, GeneratorUtil.generateNonNull(generator));
assertUnavailable(generator);
}
@SuppressWarnings({"unchecked", "rawtypes"})
static Generator<Object> createMultiplicityWrapper(
ComponentDescriptor instance, Generator<?> generator, BeneratorContext context) {
String container = instance.getContainer();
if (container == null) {
Generator<Long> longCountGenerator =
DescriptorUtil.createDynamicCountGenerator(instance, 1L, 1L, true, context);
NonNullGenerator<Integer> countGenerator =
WrapperFactory.asNonNullGenerator(
new AsIntegerGeneratorWrapper<Number>((Generator) longCountGenerator));
return new SimplifyingSingleSourceArrayGenerator(generator, countGenerator);
}
// handle container
Generator<Long> longCountGenerator;
if (instance.getLocalType().getSource() != null)
longCountGenerator =
DescriptorUtil.createDynamicCountGenerator(instance, null, null, true, context);
else
longCountGenerator =
DescriptorUtil.createDynamicCountGenerator(instance, 1L, 1L, true, context);
NonNullGenerator<Integer> countGenerator =
WrapperFactory.asNonNullGenerator(
new AsIntegerGeneratorWrapper<Number>((Generator) longCountGenerator));
if ("array".equals(container))
return new SingleSourceArrayGenerator(
generator, generator.getGeneratedType(), countGenerator);
else if ("list".equals(container))
return new SingleSourceCollectionGenerator(generator, ArrayList.class, countGenerator);
else if ("set".equals(container))
return new SingleSourceCollectionGenerator(generator, HashSet.class, countGenerator);
else if ("map".equals(container)) return (Generator<Object>) generator;
else throw new SyntaxError("Not a supported container", container);
}
@Test
public void testEntitySource() {
ArrayTypeDescriptor descriptor = createArrayType("testEntitySourceType");
descriptor.setSource(PersonSource.class.getName());
Generator<Object[]> generator =
(Generator<Object[]>)
arrayTypeGeneratorFactory.createGenerator(
descriptor, "testEntitySource", false, Uniqueness.NONE, context);
generator.init(context);
for (int i = 0; i < 2; i++) {
Object[] product = GeneratorUtil.generateNonNull(generator);
assertTrue(
"Found: " + ArrayFormat.format(product),
Arrays.equals(ALICE, product) || Arrays.equals(BOB, product));
}
assertUnavailable(generator);
}
@Test
public void testCsvDataset() {
ArrayTypeDescriptor parent = createPersonDescriptor();
ArrayTypeDescriptor descriptor = createArrayType("testCsvDataset", parent);
descriptor.setSource("org/databene/benerator/factory/dataset_{0}.csv");
descriptor.setNesting("org/databene/benerator/factory/testnesting");
descriptor.setDataset("DACH");
Generator<Object[]> generator =
(Generator<Object[]>)
arrayTypeGeneratorFactory.createGenerator(
descriptor, "testCsvDataset", false, Uniqueness.SIMPLE, context);
Generator<String> g =
WrapperFactory.applyConverter(
generator, new ArrayElementExtractor<String>(String.class, 0));
generator.init(context);
expectUniquelyGeneratedSet(g, "de", "at", "ch");
assertUnavailable(generator);
}
@Test
public void testDatabaseSource() throws Exception {
// prepare DB
DBSystem db =
new DBSystem(
"db",
HSQLUtil.getInMemoryURL("benerator"),
HSQLUtil.DRIVER,
"sa",
null,
context.getDataModel());
context.set("db", db);
try {
db.execute(
"create table agft_person ("
+ " id int NOT NULL,"
+ " name varchar(30) NOT NULL,"
+ " age int NOT NULL"
+ ")");
db.execute("insert into agft_person (id, name, age) values (1, 'Alice', 23)");
db.execute("insert into agft_person (id, name, age) values (2, 'Otto', 89)");
// prepare descriptor
ArrayTypeDescriptor parent = createPersonDescriptor();
ArrayTypeDescriptor descriptor = createArrayType("testDatabaseSource", parent);
descriptor.setSource("db");
descriptor.setSelector("select name, age from agft_person");
Generator<Object[]> generator =
(Generator<Object[]>)
arrayTypeGeneratorFactory.createGenerator(
descriptor, "testDatabaseSource", false, Uniqueness.NONE, context);
generator.init(context);
// verify results
assertEqualArrays(ALICE, GeneratorUtil.generateNonNull(generator));
Object[] p2 = GeneratorUtil.generateNonNull(generator);
assertEqualArrays(OTTO, p2);
assertUnavailable(generator);
} finally {
db.execute("drop table agft_person if exists");
db.close();
}
}
@Test(expected = IllegalArgumentException.class)
public void testApply_unique() {
Generator<String> source = new SequenceTestGenerator<String>("A", "B");
source.init(new DefaultBeneratorContext());
fcn.applyTo(source, true);
}