/** * 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 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); }
@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); } }
protected ArrayElementDescriptor getElementOfTypeOrParents( ArrayTypeDescriptor arrayType, int index) { ArrayTypeDescriptor tmp = arrayType; ArrayElementDescriptor result; while ((result = tmp.getElement(index)) == null && tmp.getParent() != null) tmp = tmp.getParent(); return result; }
private ArrayTypeDescriptor createPersonDescriptor() { ArrayTypeDescriptor arrayDescriptor = createArrayType("personType"); ArrayElementDescriptor e1 = createArrayElement(0, "string"); arrayDescriptor.addElement(e1); ArrayElementDescriptor e2 = createArrayElement(1, "int"); arrayDescriptor.addElement(e2); return arrayDescriptor; }
@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 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)); }
@SuppressWarnings("rawtypes") private Generator<?>[] createSyntheticElementGenerators( ArrayTypeDescriptor arrayType, Uniqueness uniqueness, BeneratorContext context) { Generator[] result = new Generator[arrayType.getElementCount()]; for (int i = 0; i < arrayType.getElementCount(); i++) { ArrayElementDescriptor element = getElementOfTypeOrParents(arrayType, i); if (element.getMode() != Mode.ignored) { Generator<?> generator = InstanceGeneratorFactory.createSingleInstanceGenerator(element, uniqueness, context); result[i] = generator; } } return result; }
@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); }
@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); }
@Override protected Generator<?> createHeuristicGenerator( ArrayTypeDescriptor descriptor, String instanceName, Uniqueness uniqueness, BeneratorContext context) { return new BlankArrayGenerator(descriptor.getElementCount()); }
@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); }
@Override protected Generator<Object[]> createSourceGenerator( ArrayTypeDescriptor descriptor, Uniqueness uniqueness, BeneratorContext context) { // if no sourceObject is specified, there's nothing to do String sourceName = descriptor.getSource(); if (sourceName == null) return null; // create sourceObject generator Generator<Object[]> generator = null; Object contextSourceObject = context.get(sourceName); if (contextSourceObject != null) generator = createSourceGeneratorFromObject(descriptor, context, generator, contextSourceObject); else { String lcSourceName = sourceName.toLowerCase(); if (lcSourceName.endsWith(".csv")) generator = createCSVSourceGenerator(descriptor, context, sourceName); else if (lcSourceName.endsWith(".xls")) generator = createXLSSourceGenerator(descriptor, context, sourceName); else { try { BeanSpec sourceBeanSpec = DatabeneScriptParser.resolveBeanSpec(sourceName, context); Object sourceObject = sourceBeanSpec.getBean(); if (!sourceBeanSpec.isReference() && sourceObject instanceof ContextAware) ((ContextAware) sourceObject).setContext(context); generator = createSourceGeneratorFromObject(descriptor, context, generator, sourceObject); if (sourceBeanSpec.isReference()) generator = WrapperFactory.preventClosing(generator); return generator; } catch (Exception e) { throw new UnsupportedOperationException("Unknown source type: " + sourceName); } } } if (descriptor.getFilter() != null) { Expression<Boolean> filter = new ScriptExpression<Boolean>(ScriptUtil.parseScriptText(descriptor.getFilter())); generator = new FilteringGenerator<Object[]>(generator, filter); } Distribution distribution = FactoryUtil.getDistribution(descriptor.getDistribution(), uniqueness, false, context); if (distribution != null) generator = new DistributingGenerator<Object[]>(generator, distribution, uniqueness.isUnique()); return 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(); } }
@SuppressWarnings({"unchecked", "rawtypes"}) private static Generator<Object[]> createSourceGeneratorFromObject( ArrayTypeDescriptor descriptor, BeneratorContext context, Generator<Object[]> generator, Object sourceObject) { if (sourceObject instanceof StorageSystem) { StorageSystem storage = (StorageSystem) sourceObject; String selector = descriptor.getSelector(); String subSelector = descriptor.getSubSelector(); if (!StringUtil.isEmpty(subSelector)) generator = WrapperFactory.applyHeadCycler( new DataSourceGenerator(storage.query(subSelector, false, context))); else generator = new DataSourceGenerator(storage.query(selector, false, context)); } else if (sourceObject instanceof EntitySource) { DataSourceGenerator<Entity> entityGenerator = new DataSourceGenerator<Entity>((EntitySource) sourceObject); generator = WrapperFactory.applyConverter(entityGenerator, new Entity2ArrayConverter()); } else if (sourceObject instanceof Generator) { generator = (Generator<Object[]>) sourceObject; } else throw new ConfigurationError("Source type not supported: " + sourceObject.getClass()); return generator; }
private Generator<Object[]> createXLSSourceGenerator( ArrayTypeDescriptor arrayType, BeneratorContext context, String sourceName) { logger.debug("createXLSSourceGenerator({})", arrayType); boolean rowBased = (arrayType.isRowBased() != null ? arrayType.isRowBased() : true); String emptyMarker = arrayType.getEmptyMarker(); String nullMarker = arrayType.getNullMarker(); boolean formatted = isFormatted(arrayType); DataSourceProvider<Object[]> factory = new XLSArraySourceProvider( formatted, new ScriptConverterForObjects(context), emptyMarker, nullMarker, rowBased); Generator<Object[]> generator = SourceFactory.createRawSourceGenerator( arrayType.getNesting(), arrayType.getDataset(), sourceName, factory, Object[].class, context); generator = WrapperFactory.applyConverter(generator, new ArrayElementTypeConverter(arrayType)); return generator; }
private Generator<Object[]> createCSVSourceGenerator( ArrayTypeDescriptor arrayType, BeneratorContext context, String sourceName) { logger.debug("createCSVSourceGenerator({})", arrayType); String encoding = arrayType.getEncoding(); if (encoding == null) encoding = context.getDefaultEncoding(); char separator = DescriptorUtil.getSeparator(arrayType, context); boolean rowBased = (arrayType.isRowBased() != null ? arrayType.isRowBased() : true); DataSourceProvider<Object[]> factory = new CSVArraySourceProvider( arrayType.getName(), new ScriptConverterForStrings(context), rowBased, separator, encoding); Generator<Object[]> generator = SourceFactory.createRawSourceGenerator( arrayType.getNesting(), arrayType.getDataset(), sourceName, factory, Object[].class, context); return WrapperFactory.applyConverter(generator, new ArrayElementTypeConverter(arrayType)); }