@Test public void testAverage() { Aggregator aggregator = new Average(); Tuple[] arguments = new Tuple[]{new Tuple( new Double( 1.0 ) ), new Tuple( new Double( 3.0 ) ), new Tuple( new Double( 2.0 ) ), new Tuple( new Double( 4.0 ) ), new Tuple( new Double( -5.0 ) )}; Fields resultFields = new Fields( "field" ); TupleListCollector resultEntryCollector = invokeAggregator( aggregator, arguments, resultFields ); Tuple tuple = resultEntryCollector.iterator().next(); assertEquals( "got expected value after aggregate", 1.0, tuple.getDouble( 0 ), 0.0d ); }
private Object evaluate( ExpressionFunction function, TupleEntry tupleEntry ) { TupleListCollector tuples = invokeFunction( function, tupleEntry, function.getFieldDeclaration() ); return tuples.entryIterator().next().getObject( 0 ); }
public static TupleListCollector invokeBuffer( Buffer buffer, TupleEntry group, TupleEntry[] argumentsArray, Fields resultFields, Map<Object, Object> properties ) { FlowProcess flowProcess = new TestFlowProcess( properties ); ConcreteCall operationCall = new ConcreteCall( argumentsArray[ 0 ].getFields(), buffer.getFieldDeclaration() ); operationCall.setGroup( group ); buffer.prepare( flowProcess, operationCall ); TupleListCollector collector = new TupleListCollector( resultFields, true ); operationCall.setOutputCollector( collector ); operationCall.setArgumentsIterator( Arrays.asList( argumentsArray ).iterator() ); buffer.operate( flowProcess, operationCall ); buffer.cleanup( null, operationCall ); return collector; }
@Test public void testReplace() throws IOException { RegexReplace splitter = new RegexReplace( new Fields( "words" ), "\\s+", "-", true ); Tuple arguments = new Tuple( "foo\t bar" ); Fields resultFields = Fields.UNKNOWN; TupleListCollector collector = invokeFunction( splitter, arguments, resultFields ); assertEquals( "wrong size", 1, collector.size() ); Iterator<Tuple> iterator = collector.iterator(); Tuple tuple = iterator.next(); assertEquals( "not equal: tuple.get(0)", "foo-bar", tuple.getObject( 0 ) ); }
/** * Constructor TupleEntryCollector creates a new TupleEntryCollector instance. * * @param fields of type Fields * @param tuple of type Tuple... */ public TupleListCollector( Fields fields, Tuple... tuple ) { super( fields ); collect( tuple ); }
/** * Method collect adds every given Tuple instance. It tests for and ignores empty Tuples. * * @param tuples of type Tuple */ private void collect( Tuple... tuples ) { for( Tuple tuple : tuples ) add( tuple ); }
@Test public void testSplitter() throws IOException { RegexSplitter splitter = new RegexSplitter( "\t" ); Tuple arguments = new Tuple( "foo\tbar" ); Fields resultFields = Fields.UNKNOWN; TupleListCollector collector = invokeFunction( splitter, arguments, resultFields ); assertEquals( "wrong size", 1, collector.size() ); Iterator<Tuple> iterator = collector.iterator(); Tuple tuple = iterator.next(); assertEquals( "not equal: tuple.get(0)", "foo", tuple.getObject( 0 ) ); assertEquals( "not equal: tuple.get(1)", "bar", tuple.getObject( 1 ) ); }
@Test public void testFirst() { Aggregator aggregator = new First(); Tuple[] arguments = new Tuple[]{new Tuple( new Double( 1.0 ) ), new Tuple( new Double( 3.0 ) ), new Tuple( new Double( 2.0 ) ), new Tuple( new Double( 4.0 ) ), new Tuple( new Double( -5.0 ) )}; Fields resultFields = new Fields( "field" ); TupleListCollector resultEntryCollector = invokeAggregator( aggregator, arguments, resultFields ); Tuple tuple = resultEntryCollector.iterator().next(); assertEquals( "got expected value after aggregate", 1.0, tuple.getDouble( 0 ), 0.0d ); }
@Test public void testParserUnknown2() throws IOException { RegexParser splitter = new RegexParser( "(\\S+)\\s+(\\S+)", new int[]{1, 2} ); Tuple arguments = new Tuple( "foo\tbar" ); Fields resultFields = Fields.UNKNOWN; TupleListCollector collector = invokeFunction( splitter, arguments, resultFields ); assertEquals( "wrong size", 1, collector.size() ); Iterator<Tuple> iterator = collector.iterator(); Tuple tuple = iterator.next(); assertEquals( "not equal: tuple.get(0)", "foo", tuple.getObject( 0 ) ); assertEquals( "not equal: tuple.get(1)", "bar", tuple.getObject( 1 ) ); }
private Object evaluate( ExpressionFunction function, TupleEntry tupleEntry ) { TupleListCollector tuples = invokeFunction( function, tupleEntry, function.getFieldDeclaration() ); return tuples.entryIterator().next().getObject( 0 ); }
public static TupleListCollector invokeFunction( Function function, TupleEntry arguments, Fields resultFields, Map<Object, Object> properties ) { FlowProcess flowProcess = new TestFlowProcess( properties ); ConcreteCall operationCall = new ConcreteCall( arguments.getFields(), function.getFieldDeclaration() ); TupleListCollector collector = new TupleListCollector( resultFields, true ); operationCall.setArguments( arguments ); operationCall.setOutputCollector( collector ); function.prepare( flowProcess, operationCall ); function.operate( flowProcess, operationCall ); function.cleanup( flowProcess, operationCall ); return collector; }
@Test public void testMinValue() { Aggregator aggregator = new MinValue(); Tuple[] arguments = new Tuple[]{new Tuple( new Double( 1.0 ) ), new Tuple( new Double( 3.0 ) ), new Tuple( new Double( 2.0 ) ), new Tuple( new Double( 4.0 ) ), new Tuple( new Double( -5.0 ) )}; Fields resultFields = new Fields( "field" ); TupleListCollector resultEntryCollector = invokeAggregator( aggregator, arguments, resultFields ); Tuple tuple = resultEntryCollector.iterator().next(); assertEquals( "got expected value after aggregate", -5.0, tuple.getDouble( 0 ), 0.0d ); }
@Test public void testParserUnknown() throws IOException { RegexParser splitter = new RegexParser( Fields.UNKNOWN, "(\\S+)\\s+(\\S+)", new int[]{1, 2} ); Tuple arguments = new Tuple( "foo\tbar" ); Fields resultFields = Fields.UNKNOWN; TupleListCollector collector = invokeFunction( splitter, arguments, resultFields ); assertEquals( "wrong size", 1, collector.size() ); Iterator<Tuple> iterator = collector.iterator(); Tuple tuple = iterator.next(); assertEquals( "not equal: tuple.get(0)", "foo", tuple.getObject( 0 ) ); assertEquals( "not equal: tuple.get(1)", "bar", tuple.getObject( 1 ) ); }
@Test public void testTree() { Fields predictedFields = new Fields( "label", double.class ); Fields expectedFields = Fields.NONE .append( new Fields( "var0", double.class ) ) .append( new Fields( "var1", double.class ) ) .append( new Fields( "var2", double.class ) ); ModelSchema modelSchema = new ModelSchema( expectedFields, predictedFields ); TreeSpec treeSpec = new TreeSpec( modelSchema ); Tree tree = new Tree( "1" ); tree.addPredicate( "1", "2", new LessOrEqualThanPredicate( "var0", 0.5d ) ); tree.addPredicate( "2", "4", new LessOrEqualThanPredicate( "var2", 0.5d ), "1" ); tree.addPredicate( "2", "5", new GreaterThanPredicate( "var2", 0.5d ), "0" ); tree.addPredicate( "1", "3", new GreaterThanPredicate( "var0", 0.5d ) ); tree.addPredicate( "3", "6", new LessOrEqualThanPredicate( "var1", 0.5d ), "0" ); tree.addPredicate( "3", "7", new GreaterThanPredicate( "var1", 0.5d ), "1" ); treeSpec.setTree( tree ); TreeFunction treeFunction = new TreeFunction( treeSpec ); TupleEntry tupleArguments = new TupleEntry( expectedFields, new Tuple( 0d, 1d, 0d ) ); TupleListCollector collector = invokeFunction( treeFunction, tupleArguments, predictedFields ); assertEquals( new Tuple( "1" ), collector.entryIterator().next().getTuple() ); }
public static TupleListCollector invokeFunction( Function function, TupleEntry[] argumentsArray, Fields resultFields, Map<Object, Object> properties ) { FlowProcess flowProcess = new TestFlowProcess( properties ); ConcreteCall operationCall = new ConcreteCall( argumentsArray[ 0 ].getFields(), function.getFieldDeclaration() ); TupleListCollector collector = new TupleListCollector( resultFields, true ); function.prepare( flowProcess, operationCall ); operationCall.setOutputCollector( collector ); for( TupleEntry arguments : argumentsArray ) { operationCall.setArguments( arguments ); function.operate( flowProcess, operationCall ); } function.flush( flowProcess, operationCall ); function.cleanup( flowProcess, operationCall ); return collector; }
@Test public void testCount() { Aggregator aggregator = new Count(); Tuple[] arguments = new Tuple[]{new Tuple( new Double( 1.0 ) ), new Tuple( new Double( 3.0 ) ), new Tuple( new Double( 2.0 ) ), new Tuple( new Double( 4.0 ) ), new Tuple( new Double( -5.0 ) )}; Fields resultFields = new Fields( "field" ); TupleListCollector resultEntryCollector = invokeAggregator( aggregator, arguments, resultFields ); Tuple tuple = resultEntryCollector.iterator().next(); assertEquals( "got expected value after aggregate", 5, tuple.getInteger( 0 ) ); }
@Test public void testParserUnknown3() throws IOException { RegexParser splitter = new RegexParser( "(\\S+)\\s+(\\S+)" ); Tuple arguments = new Tuple( "foo\tbar" ); Fields resultFields = Fields.UNKNOWN; TupleListCollector collector = invokeFunction( splitter, arguments, resultFields ); assertEquals( "wrong size", 1, collector.size() ); Iterator<Tuple> iterator = collector.iterator(); Tuple tuple = iterator.next(); assertEquals( "not equal: tuple.get(0)", "foo", tuple.getObject( 0 ) ); assertEquals( "not equal: tuple.get(1)", "bar", tuple.getObject( 1 ) ); }
assertEquals( new Tuple( "3" ), collector.entryIterator().next().getTuple() );
public static TupleListCollector invokeAggregator( Aggregator aggregator, TupleEntry group, TupleEntry[] argumentsArray, Fields resultFields, Map<Object, Object> properties ) { FlowProcess flowProcess = new TestFlowProcess( properties ); ConcreteCall operationCall = new ConcreteCall( argumentsArray[ 0 ].getFields(), aggregator.getFieldDeclaration() ); operationCall.setGroup( group ); aggregator.prepare( flowProcess, operationCall ); aggregator.start( flowProcess, operationCall ); for( TupleEntry arguments : argumentsArray ) { operationCall.setArguments( arguments ); aggregator.aggregate( flowProcess, operationCall ); } TupleListCollector collector = new TupleListCollector( resultFields, true ); operationCall.setOutputCollector( collector ); aggregator.complete( flowProcess, operationCall ); aggregator.cleanup( null, operationCall ); return collector; }
@Test public void testSum() { Aggregator aggregator = new Sum(); Tuple[] arguments = new Tuple[]{new Tuple( new Double( 1.0 ) ), new Tuple( new Double( 3.0 ) ), new Tuple( new Double( 2.0 ) ), new Tuple( new Double( 4.0 ) ), new Tuple( new Double( -5.0 ) )}; Fields resultFields = new Fields( "field" ); TupleListCollector resultEntryCollector = invokeAggregator( aggregator, arguments, resultFields ); Tuple tuple = resultEntryCollector.iterator().next(); assertEquals( "got expected value after aggregate", 5.0, tuple.getDouble( 0 ), 0.0d ); }