Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
HiveReaderSetting implements IReaderSetting { @Override public boolean isVectorMode(){ return isVectorModeFlag; } HiveReaderSetting( final Configuration config , final IExpressionNode node , final boolean isVectorModeFlag , final boolean disableSkipBlock , final boolean disableFilterPushdown ); HiveReaderSetting( final FileSplit split, final JobConf job ); String createReadColumnNames( final String readColumnNames ); IExpressionNode createExpressionNode( final List<ExprNodeGenericFuncDesc> filterExprs ); Set<String> createPathSet( final Path target ); @Override boolean isVectorMode(); @Override boolean isDisableSkipBlock(); @Override boolean isDisableFilterPushdown(); @Override Configuration getReaderConfig(); @Override IExpressionNode getExpressionNode(); }
@Test public void T_isVectorMode_1(){ HiveReaderSetting setting = new HiveReaderSetting( null , null , true , false , false ); assertTrue( setting.isVectorMode() ); setting = new HiveReaderSetting( null , null , false , false , false ); assertFalse( setting.isVectorMode() ); }
MDSStructObjectInspector extends SettableStructObjectInspector { @Override public boolean equals( final Object o ) { if ( o == null || o.getClass() != getClass() ) { return false; } else if ( o == this ){ return true; } else { List<StructField> other = ( (MDSStructObjectInspector) o ).fields; if ( other.size() != fields.size() ){ return false; } for( int i = 0; i < fields.size(); ++i ){ StructField left = other.get(i); StructField right = fields.get(i); if (!(left.getFieldName().equalsIgnoreCase(right.getFieldName()) && left.getFieldObjectInspector().equals (right.getFieldObjectInspector()))) { return false; } } return true; } } MDSStructObjectInspector( final StructTypeInfo typeInfo ); @Override List<StructField> getAllStructFieldRefs(); @Override StructField getStructFieldRef( final String s ); @Override Object getStructFieldData( final Object object, final StructField field ); @Override List<Object> getStructFieldsDataAsList( final Object object ); @Override String getTypeName(); @Override Category getCategory(); @Override Object create(); @Override Object setStructFieldData( final Object object, final StructField field , final Object fieldValue ); @Override boolean equals( final Object o ); }
@Test public void T_equals_1(){ MDSStructObjectInspector inspector = new MDSStructObjectInspector( getTypeInfo() ); assertTrue( inspector.equals( inspector ) ); }
MDSStructObjectInspector extends SettableStructObjectInspector { @Override public List<Object> getStructFieldsDataAsList( final Object object ){ ColumnAndIndex columnAndIndex = (ColumnAndIndex) object; List<Object> result = new ArrayList<Object>( fields.size() ); for( StructField field : fields ){ MDSStructField structFiled = (MDSStructField)field; result.add( structFiled.getValue( (ColumnAndIndex)object ) ); } return result; } MDSStructObjectInspector( final StructTypeInfo typeInfo ); @Override List<StructField> getAllStructFieldRefs(); @Override StructField getStructFieldRef( final String s ); @Override Object getStructFieldData( final Object object, final StructField field ); @Override List<Object> getStructFieldsDataAsList( final Object object ); @Override String getTypeName(); @Override Category getCategory(); @Override Object create(); @Override Object setStructFieldData( final Object object, final StructField field , final Object fieldValue ); @Override boolean equals( final Object o ); }
@Test public void T_getStructFieldsDataAsList_1() throws IOException{ MDSStructObjectInspector inspector = new MDSStructObjectInspector( getTypeInfo() ); Map<String,Object> dataContainer = new HashMap<String,Object>(); dataContainer.put( "str" , new StringObj( "a" ) ); dataContainer.put( "num" , new IntegerObj( 1 ) ); dataContainer.put( "uni" , new IntegerObj( 1 ) ); Spread spread = new Spread(); spread.addRow( dataContainer ); SpreadColumn spreadColumn = new SpreadColumn( "root" ); spreadColumn.setSpread( spread ); ColumnAndIndex columnAndIndex = new ColumnAndIndex( spreadColumn , 0 , 0 ); List<Object> result = inspector.getStructFieldsDataAsList( columnAndIndex ); assertEquals( result.get(0) , new Text( "a" ) ); assertEquals( result.get(1) , new IntWritable( 1 ) ); assertTrue( result.get(2) instanceof ColumnAndIndex ); assertTrue( result.get(3) instanceof StandardUnion ); }
ConvertArrowFormatTool { public static void convert( final MDSArrowReader arrowReader , final OutputStream out , final Configuration config ) throws IOException{ ArrowFileWriter writer = null; while( arrowReader.hasNext() ){ ValueVector vector = arrowReader.next(); if( writer == null ){ VectorSchemaRoot schema = new VectorSchemaRoot( (FieldVector)vector ); writer = new ArrowFileWriter( schema, null, Channels.newChannel( out ) ); writer.start(); } writer.writeBatch(); } if( writer != null ){ writer.end(); writer.close(); } arrowReader.close(); } private ConvertArrowFormatTool(); static Options createOptions( final String[] args ); static void printHelp( final String[] args ); static int run( final String[] args ); static void convert( final MDSArrowReader arrowReader , final OutputStream out , final Configuration config ); static void main( final String[] args ); }
@Test public void T_convert_1() throws IOException{ byte[] mdsFile = createTestData(); InputStream in = new ByteArrayInputStream( mdsFile ); MDSReader reader = new MDSReader(); Configuration config = new Configuration(); reader.setNewStream( in , mdsFile.length , config ); MDSArrowReader arrowReader = new MDSArrowReader( reader , config ); File testFile = new File( "target/TestConvertArrowFormatTool_T_convert_1.mds" ); if( testFile.exists() ){ testFile.delete(); } FileOutputStream out = new FileOutputStream( testFile ); ConvertArrowFormatTool.convert( arrowReader , out , config ); FileInputStream arrowIn = new FileInputStream( testFile ); ArrowFileReader ar = new ArrowFileReader( arrowIn.getChannel() , new RootAllocator( Integer.MAX_VALUE ) ); VectorSchemaRoot root = ar.getVectorSchemaRoot(); ArrowBlock rbBlock = ar.getRecordBlocks().get(0); ar.loadRecordBatch(rbBlock); List<FieldVector> fieldVectorList = root.getFieldVectors(); Map<String,FieldVector> vectorMap = new HashMap<String,FieldVector>(); for( FieldVector v : fieldVectorList ){ vectorMap.put( v.getField().getName() , v ); } assertTrue( vectorMap.containsKey( "col1" ) ); assertTrue( vectorMap.containsKey( "col2" ) ); assertTrue( vectorMap.containsKey( "col3" ) ); BigIntVector col1 = (BigIntVector)( vectorMap.get( "col1" ) ); VarCharVector col2 = (VarCharVector)( vectorMap.get( "col2" ) ); VarCharVector col3 = (VarCharVector)( vectorMap.get( "col3" ) ); assertEquals( col1.get(0) , 100L ); assertEquals( col1.get(1) , 200L ); assertEquals( col1.get(2) , 300L ); assertEquals( col2.getObject(0).toString() , "aaa" ); assertTrue( col2.isNull(1) ); assertTrue( col2.isNull(2) ); assertTrue( col3.isNull(0) ); assertEquals( col3.getObject(1).toString() , "BBB" ); assertEquals( col3.getObject(2).toString() , "CCC" ); testFile.delete(); ar.close(); }
MakeMDSFileStep1 { public static void main( final String[] args ) throws IOException{ new MakeMDSFileStep1().run(); } private MakeMDSFileStep1(); int run(); static void main( final String[] args ); }
@Test public void T_run_1() throws IOException{ MakeMDSFileStep1.main( null ); }
UseSpreadStep4 { public static void main( final String[] args ) throws IOException{ new UseSpreadStep4().run(); } private UseSpreadStep4(); int run(); static void main( final String[] args ); }
@Test public void T_run_1() throws IOException{ UseSpreadStep4.main( new String[0] ); }
LoadDataToSpreadStep1 { public static void main( final String[] args ) throws IOException{ new LoadDataToSpreadStep1().run(); } private LoadDataToSpreadStep1(); int run(); static void main( final String[] args ); }
@Test public void T_run_1() throws IOException{ LoadDataToSpreadStep1.main( null ); }
UseExpandSpread1 { public static void main( final String[] args ) throws IOException{ new UseExpandSpread1().run(); } private UseExpandSpread1(); int run(); static void main( final String[] args ); }
@Test public void T_run_1() throws IOException{ UseExpandSpread1.main( new String[0] ); }
UseSpreadStep2 { public static void main( final String[] args ) throws IOException{ new UseSpreadStep2().run(); } private UseSpreadStep2(); int run(); static void main( final String[] args ); }
@Test public void T_run_1() throws IOException{ UseSpreadStep2.main( new String[0] ); }
UseSpreadStep1 { public static void main( final String[] args ) throws IOException{ new UseSpreadStep1().run(); } private UseSpreadStep1(); int run(); static void main( final String[] args ); }
@Test public void T_run_1() throws IOException{ UseSpreadStep1.main( new String[0] ); }
UseSpreadStep3 { public static void main( final String[] args ) throws IOException{ new UseSpreadStep3().run(); } private UseSpreadStep3(); int run(); static void main( final String[] args ); }
@Test public void T_run_1() throws IOException{ UseSpreadStep3.main( new String[0] ); }
HiveReaderSetting implements IReaderSetting { @Override public Configuration getReaderConfig(){ return config; } HiveReaderSetting( final Configuration config , final IExpressionNode node , final boolean isVectorModeFlag , final boolean disableSkipBlock , final boolean disableFilterPushdown ); HiveReaderSetting( final FileSplit split, final JobConf job ); String createReadColumnNames( final String readColumnNames ); IExpressionNode createExpressionNode( final List<ExprNodeGenericFuncDesc> filterExprs ); Set<String> createPathSet( final Path target ); @Override boolean isVectorMode(); @Override boolean isDisableSkipBlock(); @Override boolean isDisableFilterPushdown(); @Override Configuration getReaderConfig(); @Override IExpressionNode getExpressionNode(); }
@Test public void T_getReaderConfig_1(){ HiveReaderSetting setting = new HiveReaderSetting( null , null , true , false , false ); assertEquals( null , setting.getReaderConfig() ); }
ArrowBytesMemoryAllocator implements IMemoryAllocator { @Override public void setBytes( final int index , final byte[] value ) throws IOException{ setBytes( index , value , 0 , value.length ); } ArrowBytesMemoryAllocator( final VarBinaryVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
@Test public void T_setBytes_1() throws IOException{ BufferAllocator allocator = new RootAllocator( 1024 * 1024 * 10 ); SchemaChangeCallBack callBack = new SchemaChangeCallBack(); StructVector parent = new StructVector("root", allocator, new FieldType(false, Struct.INSTANCE, null, null), callBack); parent.allocateNew(); IMemoryAllocator memoryAllocator = ArrowMemoryAllocatorFactory.getFromStructVector( ColumnType.BYTES , "target" , allocator , parent , 4 ); memoryAllocator.setBytes( 0 , "a".getBytes() ); memoryAllocator.setBytes( 1 , "b".getBytes() ); memoryAllocator.setBytes( 5 , "c".getBytes() ); memoryAllocator.setBytes( 1000 , "a b c".getBytes() ); StructReader rootReader = parent.getReader(); FieldReader reader = rootReader.reader( "target" ); reader.setPosition( 0 ); assertEquals( new String( reader.readByteArray() ) , "a" ); reader.setPosition( 1 ); assertEquals( new String( reader.readByteArray() ) , "b" ); reader.setPosition( 5 ); assertEquals( new String( reader.readByteArray() ) , "c" ); for( int i = 6 ; i < 1000 ; i++ ){ reader.setPosition( i ); assertEquals( reader.readByteArray() , null ); } reader.setPosition( 1000 ); assertEquals( new String( reader.readByteArray() ) , "a b c" ); }
ArrowFloatMemoryAllocator implements IMemoryAllocator { @Override public void setFloat( final int index , final float value ) throws IOException{ vector.setSafe( index , value ); } ArrowFloatMemoryAllocator( final Float4Vector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
@Test public void T_setFloat_1() throws IOException{ BufferAllocator allocator = new RootAllocator( 1024 * 1024 * 10 ); SchemaChangeCallBack callBack = new SchemaChangeCallBack(); StructVector parent = new StructVector("root", allocator, new FieldType(false, Struct.INSTANCE, null, null), callBack); parent.allocateNew(); IMemoryAllocator memoryAllocator = ArrowMemoryAllocatorFactory.getFromStructVector( ColumnType.FLOAT , "target" , allocator , parent , 4 ); memoryAllocator.setFloat( 0 , (float)0.1 ); memoryAllocator.setFloat( 1 , (float)0.2 ); memoryAllocator.setFloat( 5 , (float)0.255 ); memoryAllocator.setFloat( 1000 , (float)0.1 ); StructReader rootReader = parent.getReader(); FieldReader reader = rootReader.reader( "target" ); reader.setPosition( 0 ); assertEquals( reader.readFloat().floatValue() , (float)0,1 ); reader.setPosition( 1 ); assertEquals( reader.readFloat().floatValue() , (float)0.2 ); reader.setPosition( 5 ); assertEquals( reader.readFloat().floatValue() , (float)0.255 ); for( int i = 6 ; i < 1000 ; i++ ){ reader.setPosition( i ); assertEquals( reader.readFloat() , null ); } reader.setPosition( 1000 ); assertEquals( reader.readFloat().floatValue() , (float)0.1 ); }
ArrowIntegerMemoryAllocator implements IMemoryAllocator { @Override public void setInteger( final int index , final int value ) throws IOException{ vector.setSafe( index , value ); } ArrowIntegerMemoryAllocator( final IntVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
@Test public void T_setInteger_1() throws IOException{ BufferAllocator allocator = new RootAllocator( 1024 * 1024 * 10 ); SchemaChangeCallBack callBack = new SchemaChangeCallBack(); StructVector parent = new StructVector("root", allocator, new FieldType(false, Struct.INSTANCE, null, null), callBack); parent.allocateNew(); IMemoryAllocator memoryAllocator = ArrowMemoryAllocatorFactory.getFromStructVector( ColumnType.INTEGER , "target" , allocator , parent , 1001 ); memoryAllocator.setInteger( 0 , 100 ); memoryAllocator.setInteger( 1 , 200 ); memoryAllocator.setInteger( 5 , 255 ); memoryAllocator.setInteger( 1000 , 10 ); StructReader rootReader = parent.getReader(); FieldReader reader = rootReader.reader( "target" ); reader.setPosition( 0 ); assertEquals( reader.readInteger().intValue() , 100 ); reader.setPosition( 1 ); assertEquals( reader.readInteger().intValue() , 200 ); reader.setPosition( 5 ); assertEquals( reader.readInteger().intValue() , 255 ); for( int i = 6 ; i < 1000 ; i++ ){ reader.setPosition( i ); assertEquals( reader.readInteger() , null ); } reader.setPosition( 1000 ); assertEquals( reader.readInteger().intValue() , 10 ); }
ArrowStringMemoryAllocator implements IMemoryAllocator { @Override public void setString( final int index , final String value ) throws IOException{ byte[] strBytes = value.getBytes( "UTF-8" ); setBytes( index , strBytes ); } ArrowStringMemoryAllocator( final VarCharVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
@Test public void T_setString_1() throws IOException{ BufferAllocator allocator = new RootAllocator( 1024 * 1024 * 10 ); SchemaChangeCallBack callBack = new SchemaChangeCallBack(); StructVector parent = new StructVector("root", allocator, new FieldType(false, Struct.INSTANCE, null, null), callBack); parent.allocateNew(); IMemoryAllocator memoryAllocator = ArrowMemoryAllocatorFactory.getFromStructVector( ColumnType.STRING , "target" , allocator , parent , 4 ); memoryAllocator.setString( 0 , "a" ); memoryAllocator.setString( 1 , "b" ); memoryAllocator.setString( 5 , "c" ); memoryAllocator.setString( 1000 , "a b c" ); StructReader rootReader = parent.getReader(); FieldReader reader = rootReader.reader( "target" ); reader.setPosition( 0 ); assertEquals( reader.readText().toString() , "a" ); reader.setPosition( 1 ); assertEquals( reader.readText().toString() , "b" ); reader.setPosition( 5 ); assertEquals( reader.readText().toString() , "c" ); for( int i = 6 ; i < 1000 ; i++ ){ reader.setPosition( i ); assertEquals( reader.readText() , null ); } reader.setPosition( 1000 ); assertEquals( reader.readText().toString() , "a b c" ); }
ArrowShortMemoryAllocator implements IMemoryAllocator { @Override public void setShort( final int index , final short value ) throws IOException{ vector.setSafe( index , value ); } ArrowShortMemoryAllocator( final SmallIntVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
@Test public void T_setShort_1() throws IOException{ BufferAllocator allocator = new RootAllocator( 1024 * 1024 * 10 ); SchemaChangeCallBack callBack = new SchemaChangeCallBack(); StructVector parent = new StructVector("root", allocator, new FieldType(false, Struct.INSTANCE, null, null), callBack); parent.allocateNew(); IMemoryAllocator memoryAllocator = ArrowMemoryAllocatorFactory.getFromStructVector( ColumnType.SHORT , "target" , allocator , parent , 1001 ); memoryAllocator.setShort( 0 , (short)100 ); memoryAllocator.setShort( 1 , (short)200 ); memoryAllocator.setShort( 5 , (short)255 ); memoryAllocator.setShort( 1000 , (short)10 ); StructReader rootReader = parent.getReader(); FieldReader reader = rootReader.reader( "target" ); reader.setPosition( 0 ); assertEquals( (short)( reader.readShort() ) , (short)100 ); reader.setPosition( 1 ); assertEquals( (short)( reader.readShort() ) , (short)200 ); reader.setPosition( 5 ); assertEquals( (short)( reader.readShort() ) , (short)255 ); for( int i = 6 ; i < 1000 ; i++ ){ reader.setPosition( i ); assertEquals( reader.readShort() , null ); } reader.setPosition( 1000 ); assertEquals( (short)( reader.readShort() ) , (short)10 ); }
ArrowLongMemoryAllocator implements IMemoryAllocator { @Override public void setLong( final int index , final long value ) throws IOException{ vector.setSafe( index , value ); } ArrowLongMemoryAllocator( final BigIntVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
@Test public void T_setLong_1() throws IOException{ BufferAllocator allocator = new RootAllocator( 1024 * 1024 * 10 ); SchemaChangeCallBack callBack = new SchemaChangeCallBack(); StructVector parent = new StructVector("root", allocator, new FieldType(false, Struct.INSTANCE, null, null), callBack); parent.allocateNew(); IMemoryAllocator memoryAllocator = ArrowMemoryAllocatorFactory.getFromStructVector( ColumnType.LONG , "target" , allocator , parent , 1001 ); memoryAllocator.setLong( 0 , (long)100 ); memoryAllocator.setLong( 1 , (long)200 ); memoryAllocator.setLong( 5 , (long)255 ); memoryAllocator.setLong( 1000 , (long)10 ); StructReader rootReader = parent.getReader(); FieldReader reader = rootReader.reader( "target" ); reader.setPosition( 0 ); assertEquals( reader.readLong().longValue() , (long)100 ); reader.setPosition( 1 ); assertEquals( reader.readLong().longValue() , (long)200 ); reader.setPosition( 5 ); assertEquals( reader.readLong().longValue() , (long)255 ); for( int i = 6 ; i < 1000 ; i++ ){ reader.setPosition( i ); assertEquals( reader.readLong() , null ); } reader.setPosition( 1000 ); assertEquals( reader.readLong().longValue() , (long)10 ); }
ArrowBooleanMemoryAllocator implements IMemoryAllocator { @Override public void setBoolean( final int index , final boolean value ) throws IOException{ if( value ){ vector.setSafe( index , 1 ); } else{ vector.setSafe( index , 0 ); } } ArrowBooleanMemoryAllocator( final BitVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
@Test public void T_setBoolean_1() throws IOException{ BufferAllocator allocator = new RootAllocator( 1024 * 1024 * 10 ); SchemaChangeCallBack callBack = new SchemaChangeCallBack(); StructVector parent = new StructVector("root", allocator, new FieldType(false, Struct.INSTANCE, null, null), callBack); parent.allocateNew(); IMemoryAllocator memoryAllocator = ArrowMemoryAllocatorFactory.getFromStructVector( ColumnType.BOOLEAN , "target" , allocator , parent , 4 ); memoryAllocator.setBoolean( 0 , true ); memoryAllocator.setBoolean( 1 , false ); memoryAllocator.setBoolean( 5 , true ); memoryAllocator.setBoolean( 1000 , true ); StructReader rootReader = parent.getReader(); FieldReader reader = rootReader.reader( "target" ); reader.setPosition( 0 ); assertEquals( reader.readBoolean().booleanValue() , true ); reader.setPosition( 1 ); assertEquals( reader.readBoolean().booleanValue() , false ); reader.setPosition( 5 ); assertEquals( reader.readBoolean().booleanValue() , true ); for( int i = 6 ; i < 1000 ; i++ ){ reader.setPosition( i ); assertEquals( reader.readBoolean() , null ); } reader.setPosition( 1000 ); assertEquals( reader.readBoolean().booleanValue() , true ); }
ArrowByteMemoryAllocator implements IMemoryAllocator { @Override public void setByte( final int index , final byte value ) throws IOException{ vector.setSafe( index , value ); } ArrowByteMemoryAllocator( final TinyIntVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
@Test public void T_setByte_1() throws IOException{ BufferAllocator allocator = new RootAllocator( 1024 * 1024 * 10 ); SchemaChangeCallBack callBack = new SchemaChangeCallBack(); StructVector parent = new StructVector("root", allocator, new FieldType(false, Struct.INSTANCE, null, null), callBack); parent.allocateNew(); IMemoryAllocator memoryAllocator = ArrowMemoryAllocatorFactory.getFromStructVector( ColumnType.BYTE , "target" , allocator , parent , 1001 ); memoryAllocator.setByte( 0 , (byte)100 ); memoryAllocator.setByte( 1 , (byte)200 ); memoryAllocator.setByte( 5 , (byte)255 ); memoryAllocator.setByte( 1000 , (byte)10 ); StructReader rootReader = parent.getReader(); FieldReader reader = rootReader.reader( "target" ); reader.setPosition( 0 ); assertEquals( reader.readByte().byteValue() , (byte)100 ); reader.setPosition( 1 ); assertEquals( reader.readByte().byteValue() , (byte)200 ); reader.setPosition( 5 ); assertEquals( reader.readByte().byteValue() , (byte)255 ); for( int i = 6 ; i < 1000 ; i++ ){ reader.setPosition( i ); assertEquals( reader.readByte() , null ); } reader.setPosition( 1000 ); assertEquals( reader.readByte().byteValue() , (byte)10 ); }
ArrowDoubleMemoryAllocator implements IMemoryAllocator { @Override public void setDouble( final int index , final double value ) throws IOException{ vector.setSafe( index , value ); } ArrowDoubleMemoryAllocator( final Float8Vector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
@Test public void T_setDouble_1() throws IOException{ BufferAllocator allocator = new RootAllocator( 1024 * 1024 * 10 ); SchemaChangeCallBack callBack = new SchemaChangeCallBack(); StructVector parent = new StructVector("root", allocator, new FieldType(false, Struct.INSTANCE, null, null), callBack); parent.allocateNew(); IMemoryAllocator memoryAllocator = ArrowMemoryAllocatorFactory.getFromStructVector( ColumnType.DOUBLE , "target" , allocator , parent , 4 ); memoryAllocator.setDouble( 0 , (double)0.1 ); memoryAllocator.setDouble( 1 , (double)0.2 ); memoryAllocator.setDouble( 5 , (double)0.255 ); memoryAllocator.setDouble( 1000 , (double)0.1 ); StructReader rootReader = parent.getReader(); FieldReader reader = rootReader.reader( "target" ); reader.setPosition( 0 ); assertEquals( reader.readDouble().doubleValue() , (double)0,1 ); reader.setPosition( 1 ); assertEquals( reader.readDouble().doubleValue() , (double)0.2 ); reader.setPosition( 5 ); assertEquals( reader.readDouble().doubleValue() , (double)0.255 ); for( int i = 6 ; i < 1000 ; i++ ){ reader.setPosition( i ); assertEquals( reader.readDouble() , null ); } reader.setPosition( 1000 ); assertEquals( reader.readDouble().doubleValue() , (double)0.1 ); }
FloatRangeBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_FLOAT; } FloatRangeBlockIndex(); FloatRangeBlockIndex( final Float min , final Float max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); Float getMin(); Float getMax(); }
@Test public void T_getBlockIndexType_1(){ IBlockIndex bIndex = new FloatRangeBlockIndex(); assertEquals( BlockIndexType.RANGE_FLOAT , bIndex.getBlockIndexType() ); }
HiveReaderSetting implements IReaderSetting { @Override public IExpressionNode getExpressionNode(){ return node; } HiveReaderSetting( final Configuration config , final IExpressionNode node , final boolean isVectorModeFlag , final boolean disableSkipBlock , final boolean disableFilterPushdown ); HiveReaderSetting( final FileSplit split, final JobConf job ); String createReadColumnNames( final String readColumnNames ); IExpressionNode createExpressionNode( final List<ExprNodeGenericFuncDesc> filterExprs ); Set<String> createPathSet( final Path target ); @Override boolean isVectorMode(); @Override boolean isDisableSkipBlock(); @Override boolean isDisableFilterPushdown(); @Override Configuration getReaderConfig(); @Override IExpressionNode getExpressionNode(); }
@Test public void T_getExpressionNode_1(){ HiveReaderSetting setting = new HiveReaderSetting( null , null , true , false , false ); assertEquals( null , setting.getExpressionNode() ); }
FloatRangeBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return Float.BYTES * 2; } FloatRangeBlockIndex(); FloatRangeBlockIndex( final Float min , final Float max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); Float getMin(); Float getMax(); }
@Test public void T_getBinarySize_1(){ FloatRangeBlockIndex bIndex = new FloatRangeBlockIndex( (float)10 , (float)20 ); assertEquals( Float.BYTES * 2 , bIndex.getBinarySize() ); }
BlockIndexNode { public int getBinarySize() throws IOException{ if( isDisable ){ return 0; } int length = 0; length += Integer.BYTES; if( blockIndex != null ){ length += Integer.BYTES; length += RangeBlockIndexNameShortCut.getShortCutName( blockIndex.getClass().getName() ).getBytes( "UTF-8" ).length; length += Integer.BYTES; length += blockIndex.getBinarySize(); } length += Integer.BYTES; for( Map.Entry<String,BlockIndexNode> entry : childContainer.entrySet() ){ int childLength = entry.getValue().getBinarySize(); if( childLength != 0 ){ length += Integer.BYTES; length += Integer.BYTES; length += entry.getKey().getBytes( "UTF-8" ).length; length += Integer.BYTES; length += childLength; } } return length; } BlockIndexNode(); void setBlockIndex( final IBlockIndex blockIndex ); void disable(); IBlockIndex getBlockIndex(); BlockIndexNode getChildNode( final String nodeName ); void putChildNode( final String nodeName , final BlockIndexNode node ); int getBinarySize(); int toBinary( final byte[] buffer , final int start ); void clear(); static BlockIndexNode createFromBinary( final byte[] buffer , final int start ); }
@Test public void T_getBinarySize_1() throws IOException{ BlockIndexNode b = new BlockIndexNode(); assertEquals( 8 , b.getBinarySize() ); }
StringRangeBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_STRING; } StringRangeBlockIndex(); StringRangeBlockIndex( final String min , final String max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); String getMin(); String getMax(); }
@Test public void T_getBlockIndexType_1(){ IBlockIndex bIndex = new StringRangeBlockIndex(); assertEquals( BlockIndexType.RANGE_STRING , bIndex.getBlockIndexType() ); }
StringRangeBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return ( min.length() * 2 ) + ( max.length() * 2 ) + 4 + 4; } StringRangeBlockIndex(); StringRangeBlockIndex( final String min , final String max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); String getMin(); String getMax(); }
@Test public void T_getBinarySize_1(){ StringRangeBlockIndex bIndex = new StringRangeBlockIndex( "10" , "20" ); assertEquals( Integer.BYTES * 2 + Character.BYTES * 4 , bIndex.getBinarySize() ); }
ByteRangeBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_BYTE; } ByteRangeBlockIndex(); ByteRangeBlockIndex( final byte min , final byte max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); byte getMin(); byte getMax(); }
@Test public void T_getBlockIndexType_1(){ IBlockIndex bIndex = new ByteRangeBlockIndex(); assertEquals( BlockIndexType.RANGE_BYTE , bIndex.getBlockIndexType() ); }
ByteRangeBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return Byte.BYTES * 2; } ByteRangeBlockIndex(); ByteRangeBlockIndex( final byte min , final byte max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); byte getMin(); byte getMax(); }
@Test public void T_getBinarySize_1(){ ByteRangeBlockIndex bIndex = new ByteRangeBlockIndex( (byte)10 , (byte)20 ); assertEquals( 2 , bIndex.getBinarySize() ); }
UnsupportedBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.UNSUPPORTED; } @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); static final IBlockIndex INSTANCE; }
@Test public void T_getBlockIndexType_1(){ assertEquals( BlockIndexType.UNSUPPORTED , UnsupportedBlockIndex.INSTANCE.getBlockIndexType() ); }
UnsupportedBlockIndex implements IBlockIndex { @Override public boolean merge( final IBlockIndex blockIndex ){ return false; } @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); static final IBlockIndex INSTANCE; }
@Test public void T_merge_1(){ assertFalse( UnsupportedBlockIndex.INSTANCE.merge( null ) ); }
UnsupportedBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return 0; } @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); static final IBlockIndex INSTANCE; }
@Test public void T_getBinarySize_1(){ assertEquals( 0 , UnsupportedBlockIndex.INSTANCE.getBinarySize() ); }
UnsupportedBlockIndex implements IBlockIndex { @Override public byte[] toBinary(){ return new byte[0]; } @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); static final IBlockIndex INSTANCE; }
@Test public void T_binary_1(){ byte[] binary = UnsupportedBlockIndex.INSTANCE.toBinary(); assertEquals( 0 , binary.length ); }
ParserWritable implements Writable { @Override public void write( final DataOutput dataOutput ) throws IOException { throw new UnsupportedOperationException("write unsupported"); } void set( final IParser parser ); @Override void write( final DataOutput dataOutput ); @Override void readFields( final DataInput dataInput ); public IParser parser; }
@Test public void T_write_1() throws IOException{ ParserWritable writable = new ParserWritable(); assertThrows( UnsupportedOperationException.class , () -> { writable.write( null ); } ); }
Promise { public static Promise <List <Object>> all (Promise <?>... promises) { return all (Arrays.asList (promises)); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); static OnResolved <T, U> resolved(ResolveNoReturn <T> resolveNoReturn); static OnRejected rejected(RejectNoReturn rejectNoReturn); static T await(Promise <T> promise); static T await(Promise <T> promise, boolean interruptible); static T await(Promise <T> promise, Date deadline); static T await(Promise <T> promise, long nanos); static T await(Promise <T> promise, long time, TimeUnit unit); String getName(); Status getStatus(); boolean isCancelled(); boolean isPending(); boolean isResolved(); boolean isRejected(); boolean cancel(); boolean cancel(boolean mayInterruptIfRunning); Promise <U> then(OnResolved <T, U> onResolved); Promise <U> then(OnResolvedExecutor <T, U> onResolved); Promise <U> then(OnResolved <T, U> onResolved, OnRejected onRejected); Promise <U> _catch(OnRejected onRejected); Promise <U> _catch(OnRejectedExecutor onRejected); @SuppressWarnings ("unchecked") Promise <U> then(OnResolvedExecutor <T, U> onResolved, OnRejectedExecutor <U> onRejected); static Promise <T> resolve(T value); static Promise <T> value(T value); static Promise <T> reject(Throwable reason); static Promise <List <Object>> all(Promise <?>... promises); static Promise <List <Object>> all(final List <Promise <?>> promises); static Promise <U> race(Promise <U>... promises); static Promise <U> race(final List <Promise <U>> promises); static final OnRejected ignoreReason; }
@Test public void testAll () throws Exception { synchronized (this.lock_) { Promise<List<Object>> p = Promise.all ( new Promise<> (settlement -> settlement.resolve (10)), new Promise<> (settlement -> settlement.resolve (20)) ); p.then (resolved (values -> { Assert.assertEquals (2, values.size ()); Assert.assertEquals (10, values.get (0)); Assert.assertEquals (20, values.get (1)); this.isComplete_ = true; synchronized (this.lock_) { this.lock_.notify (); } })); this.lock_.wait (5000); Assert.assertTrue (this.isComplete_); } }
Promise { public static <U> Promise <U> race (Promise <U>... promises) { return race (Arrays.asList (promises)); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); static OnResolved <T, U> resolved(ResolveNoReturn <T> resolveNoReturn); static OnRejected rejected(RejectNoReturn rejectNoReturn); static T await(Promise <T> promise); static T await(Promise <T> promise, boolean interruptible); static T await(Promise <T> promise, Date deadline); static T await(Promise <T> promise, long nanos); static T await(Promise <T> promise, long time, TimeUnit unit); String getName(); Status getStatus(); boolean isCancelled(); boolean isPending(); boolean isResolved(); boolean isRejected(); boolean cancel(); boolean cancel(boolean mayInterruptIfRunning); Promise <U> then(OnResolved <T, U> onResolved); Promise <U> then(OnResolvedExecutor <T, U> onResolved); Promise <U> then(OnResolved <T, U> onResolved, OnRejected onRejected); Promise <U> _catch(OnRejected onRejected); Promise <U> _catch(OnRejectedExecutor onRejected); @SuppressWarnings ("unchecked") Promise <U> then(OnResolvedExecutor <T, U> onResolved, OnRejectedExecutor <U> onRejected); static Promise <T> resolve(T value); static Promise <T> value(T value); static Promise <T> reject(Throwable reason); static Promise <List <Object>> all(Promise <?>... promises); static Promise <List <Object>> all(final List <Promise <?>> promises); static Promise <U> race(Promise <U>... promises); static Promise <U> race(final List <Promise <U>> promises); static final OnRejected ignoreReason; }
@Test public void testRace () throws Exception { synchronized (this.lock_) { Promise<Integer> p = Promise.race ( new Promise<> (settlement -> { { try { Thread.sleep (500); settlement.resolve (10); } catch (InterruptedException e) { settlement.reject (e); } } }), new Promise<> (settlement -> { { try { Thread.sleep (300); settlement.resolve (20); } catch (InterruptedException e) { settlement.reject (e); } } }), new Promise<> (settlement -> { { try { Thread.sleep (600); settlement.resolve (30); } catch (InterruptedException e) { settlement.reject (e); } } }) ); p.then (resolved (value -> { Assert.assertEquals (20, (int) value); Assert.assertFalse (isComplete_); isComplete_ = true; synchronized (lock_) { lock_.notify (); } })) ._catch (rejected (reason -> Assert.fail ())); this.lock_.wait (5000); Assert.assertTrue (this.isComplete_); } }
Promise { public boolean cancel () { return this.cancel (true); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); static OnResolved <T, U> resolved(ResolveNoReturn <T> resolveNoReturn); static OnRejected rejected(RejectNoReturn rejectNoReturn); static T await(Promise <T> promise); static T await(Promise <T> promise, boolean interruptible); static T await(Promise <T> promise, Date deadline); static T await(Promise <T> promise, long nanos); static T await(Promise <T> promise, long time, TimeUnit unit); String getName(); Status getStatus(); boolean isCancelled(); boolean isPending(); boolean isResolved(); boolean isRejected(); boolean cancel(); boolean cancel(boolean mayInterruptIfRunning); Promise <U> then(OnResolved <T, U> onResolved); Promise <U> then(OnResolvedExecutor <T, U> onResolved); Promise <U> then(OnResolved <T, U> onResolved, OnRejected onRejected); Promise <U> _catch(OnRejected onRejected); Promise <U> _catch(OnRejectedExecutor onRejected); @SuppressWarnings ("unchecked") Promise <U> then(OnResolvedExecutor <T, U> onResolved, OnRejectedExecutor <U> onRejected); static Promise <T> resolve(T value); static Promise <T> value(T value); static Promise <T> reject(Throwable reason); static Promise <List <Object>> all(Promise <?>... promises); static Promise <List <Object>> all(final List <Promise <?>> promises); static Promise <U> race(Promise <U>... promises); static Promise <U> race(final List <Promise <U>> promises); static final OnRejected ignoreReason; }
@Test public void testCancel () throws Exception { synchronized (this.lock_) { Promise<Integer> p1 = new Promise<> (settlement -> { try { Thread.sleep (300); } catch (InterruptedException e) { this.isComplete_ = true; } }); Thread.sleep (100); p1.cancel (true); p1.then (resolved (value -> this.isComplete_ = false)); this.lock_.wait (100); Assert.assertTrue (p1.isCancelled ()); Assert.assertTrue (this.isComplete_); } }
Promise { public static <T> T await (Promise <T> promise) throws Throwable { return await (promise, true); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); static OnResolved <T, U> resolved(ResolveNoReturn <T> resolveNoReturn); static OnRejected rejected(RejectNoReturn rejectNoReturn); static T await(Promise <T> promise); static T await(Promise <T> promise, boolean interruptible); static T await(Promise <T> promise, Date deadline); static T await(Promise <T> promise, long nanos); static T await(Promise <T> promise, long time, TimeUnit unit); String getName(); Status getStatus(); boolean isCancelled(); boolean isPending(); boolean isResolved(); boolean isRejected(); boolean cancel(); boolean cancel(boolean mayInterruptIfRunning); Promise <U> then(OnResolved <T, U> onResolved); Promise <U> then(OnResolvedExecutor <T, U> onResolved); Promise <U> then(OnResolved <T, U> onResolved, OnRejected onRejected); Promise <U> _catch(OnRejected onRejected); Promise <U> _catch(OnRejectedExecutor onRejected); @SuppressWarnings ("unchecked") Promise <U> then(OnResolvedExecutor <T, U> onResolved, OnRejectedExecutor <U> onRejected); static Promise <T> resolve(T value); static Promise <T> value(T value); static Promise <T> reject(Throwable reason); static Promise <List <Object>> all(Promise <?>... promises); static Promise <List <Object>> all(final List <Promise <?>> promises); static Promise <U> race(Promise <U>... promises); static Promise <U> race(final List <Promise <U>> promises); static final OnRejected ignoreReason; }
@Test public void testAwaitResolved () throws Throwable { int result = await (this.makeSimplePromise (5, 2000)); Assert.assertEquals (result, 5); } @Test public void testAwaitRejected () { try { await (this.makeSimplePromise (new IllegalStateException ("REJECTED"), 2000)); Assert.fail ("The promise should have been rejected"); } catch (Throwable e) { Assert.assertEquals ("REJECTED", e.getMessage ()); } }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
@Test public final void testAddValueSUM1() { final StatisticalOperation statisticalOperation = new StatisticalOperation(10, STATISTICAL_OPERATIONS.SUM); statisticalOperation.addValue(1); statisticalOperation.addValue(2); statisticalOperation.addValue(3); statisticalOperation.addValue(4); statisticalOperation.addValue(5); statisticalOperation.addValue(6); statisticalOperation.addValue(7); statisticalOperation.addValue(8); statisticalOperation.addValue(9); assertEquals(55, statisticalOperation.addValue(10), 0.0); } @Test public final void testAddValueSUM2() { final StatisticalOperation statisticalOperation = new StatisticalOperation(10, STATISTICAL_OPERATIONS.SUM); statisticalOperation.addValue(1); statisticalOperation.addValue(2); statisticalOperation.addValue(3); statisticalOperation.addValue(4); statisticalOperation.addValue(5); statisticalOperation.addValue(6); statisticalOperation.addValue(7); statisticalOperation.addValue(8); statisticalOperation.addValue(9); statisticalOperation.addValue(10); assertEquals(66, statisticalOperation.addValue(11), 0.0); } @Test public final void testAddValueAVG() { final StatisticalOperation statisticalOperation = new StatisticalOperation(10, STATISTICAL_OPERATIONS.AVG); statisticalOperation.addValue(1); assertEquals(2, statisticalOperation.addValue(3), 0.0); } @Test public final void testAddValueMAX() { final StatisticalOperation statisticalOperation = new StatisticalOperation(10, STATISTICAL_OPERATIONS.MAX); statisticalOperation.addValue(1); assertEquals(3, statisticalOperation.addValue(3), 0.0); } @Test public final void testAddValueMIN() { final StatisticalOperation statisticalOperation = new StatisticalOperation(10, STATISTICAL_OPERATIONS.MIN); statisticalOperation.addValue(1); assertEquals(1, statisticalOperation.addValue(3), 0.0); } @Test public final void testAddValueMEDIAN1() { final StatisticalOperation statisticalOperation = new StatisticalOperation(10, STATISTICAL_OPERATIONS.MEDIAN); statisticalOperation.addValue(1); assertEquals(1, statisticalOperation.addValue(3), 0.0); } @Test public final void testAddValueMEDIAN2() { final StatisticalOperation statisticalOperation = new StatisticalOperation(10, STATISTICAL_OPERATIONS.MEDIAN); statisticalOperation.addValue(1); statisticalOperation.addValue(4); statisticalOperation.addValue(7); statisticalOperation.addValue(5); assertEquals(4, statisticalOperation.addValue(3), 0.0); } @Test public final void testAddValueMEDIAN3() { final StatisticalOperation statisticalOperation = new StatisticalOperation(10, STATISTICAL_OPERATIONS.MEDIAN); statisticalOperation.addValue(1); statisticalOperation.addValue(1); statisticalOperation.addValue(5); statisticalOperation.addValue(6); statisticalOperation.addValue(20); statisticalOperation.addValue(1000); statisticalOperation.addValue(5); statisticalOperation.addValue(1); statisticalOperation.addValue(9); statisticalOperation.addValue(2); statisticalOperation.addValue(7); statisticalOperation.addValue(8); statisticalOperation.addValue(1); statisticalOperation.addValue(4); statisticalOperation.addValue(7); assertEquals(5, statisticalOperation.addValue(6), 0.0); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void clear() { if (threadSafe) { synchronized (lock) { final Set<DrawingObject> dos = tree.searchItems(); for (final DrawingObject dob : dos) { dob.removeBoundingBoxChangeListener(this); } tree.clear(); insertionOrder.clear(); insertionOrderLargest = 0; insertionOrderSmallest = 0; } } else { final Set<DrawingObject> dos = tree.searchItems(); for (final DrawingObject dob : dos) { dob.removeBoundingBoxChangeListener(this); } tree.clear(); insertionOrder.clear(); insertionOrderLargest = 0; insertionOrderSmallest = 0; } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
@Test public void testClear() { addAllRectangles(); assertTrue(tree.getDrawingObjects().size() == 4); tree.clear(); assertTrue(tree.getDrawingObjects().isEmpty()); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
@Test public void testContains() { addAllRectangles(); assertTrue(tree.getDrawingObjects(rectangle1.getBoundingBox()).contains(rectangle1)); assertTrue(tree.getDrawingObjects(rectangle2.getBoundingBox()).contains(rectangle2)); assertTrue(tree.getDrawingObjects(rectangle3.getBoundingBox()).contains(rectangle3)); assertTrue(tree.getDrawingObjects(rectangle4.getBoundingBox()).contains(rectangle4)); } @Test public void testGetDrawingObjects() { addAllRectangles(); final Set<DrawingObject> set = tree.getDrawingObjects(); assertTrue(set.size() == 4); assertTrue(set.contains(rectangle1)); assertTrue(set.contains(rectangle2)); assertTrue(set.contains(rectangle3)); assertTrue(set.contains(rectangle4)); } @Test public void testgetDrawingObjectsRectangle() { addAllRectangles(); Set<DrawingObject> collisionEntities; collisionEntities = tree.getDrawingObjects(new AbsoluteRectangle(upperLeftX, upperLeftY, width, height)); assertTrue(collisionEntities.contains(rectangle1)); assertTrue(collisionEntities.contains(rectangle2)); assertTrue(collisionEntities.contains(rectangle3)); assertTrue(collisionEntities.contains(rectangle4)); collisionEntities = tree.getDrawingObjects(upperLeftQuadrant); assertTrue(collisionEntities.size() == 1); assertTrue(collisionEntities.contains(rectangle1)); collisionEntities = tree.getDrawingObjects(upperRightQuadrant); assertTrue(collisionEntities.size() == 1); assertTrue(collisionEntities.contains(rectangle2)); collisionEntities = tree.getDrawingObjects(lowerRightQuadrant); assertTrue(collisionEntities.size() == 1); assertTrue(collisionEntities.contains(rectangle3)); collisionEntities = tree.getDrawingObjects(lowerLeftQuadrant); assertTrue(collisionEntities.size() == 1); assertTrue(collisionEntities.contains(rectangle4)); } @Test public void testSearchPoint() { addAllRectangles(); Set<DrawingObject> search; final AbsolutePosition rect1pos = rectangle1.getPosition(); final AbsolutePosition rect2pos = rectangle2.getPosition(); final AbsolutePosition rect3pos = rectangle3.getPosition(); final AbsolutePosition rect4pos = rectangle4.getPosition(); search = tree.getDrawingObjects(new AbsoluteRectangle(rect1pos.x + rectangle1.getWidth() / 2, rect1pos.y + rectangle1.getHeight() / 2, 1, 1)); assertTrue(search.contains(rectangle1)); search = tree.getDrawingObjects(new AbsoluteRectangle(rect2pos.x + rectangle1.getWidth() / 2, rect2pos.y + rectangle1.getHeight() / 2, 1, 1)); assertTrue(search.contains(rectangle2)); search = tree.getDrawingObjects(new AbsoluteRectangle(rect3pos.x + rectangle1.getWidth() / 2, rect3pos.y + rectangle1.getHeight() / 2, 1, 1)); assertTrue(search.contains(rectangle3)); search = tree.getDrawingObjects(new AbsoluteRectangle(rect4pos.x + rectangle1.getWidth() / 2, rect4pos.y + rectangle1.getHeight() / 2, 1, 1)); assertTrue(search.contains(rectangle4)); search = tree.getDrawingObjects(new AbsoluteRectangle(upperLeftX + (width * 1 / 4), upperLeftY + (height * 1 / 4), 1, 1)); assertTrue(search.isEmpty()); search = tree.getDrawingObjects(new AbsoluteRectangle(upperLeftX + (width * 3 / 4), upperLeftY + (height * 1 / 4), 1, 1)); assertTrue(search.isEmpty()); search = tree.getDrawingObjects(new AbsoluteRectangle(upperLeftX + (width * 1 / 4), upperLeftY + (height * 3 / 4), 1, 1)); assertTrue(search.isEmpty()); search = tree.getDrawingObjects(new AbsoluteRectangle(upperLeftX + (width * 3 / 4), upperLeftY + (height * 3 / 4), 1, 1)); assertTrue(search.isEmpty()); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void pushBack(final DrawingObject object) { if (threadSafe) { synchronized (lock) { insertionOrder.put(object, --insertionOrderSmallest); } } else { insertionOrder.put(object, --insertionOrderSmallest); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
@Test public void testPushBack() { Set<DrawingObject> set; addAllRectangles(); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[3] == rectangle4); assertTrue(set.toArray()[0] == rectangle1); tree.pushBack(rectangle1); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[0] == rectangle1); tree.pushBack(rectangle2); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[0] == rectangle2); tree.pushBack(rectangle3); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[0] == rectangle3); tree.pushBack(rectangle4); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[0] == rectangle4); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void remove(final DrawingObject d) { if (threadSafe) { final Rectangle rect = d.getBoundingBox().rectangle; synchronized (lock) { tree.removeItem(d, rect); d.removeBoundingBoxChangeListener(this); insertionOrder.remove(d); } } else { tree.removeItem(d, d.getBoundingBox().rectangle); d.removeBoundingBoxChangeListener(this); insertionOrder.remove(d); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
@Test public void testRemove() { addAllRectangles(); tree.remove(rectangle1); assertFalse(tree.getDrawingObjects().contains(rectangle1)); assertTrue(tree.getDrawingObjects().contains(rectangle2)); assertTrue(tree.getDrawingObjects().contains(rectangle3)); assertTrue(tree.getDrawingObjects().contains(rectangle4)); tree.remove(rectangle2); assertFalse(tree.getDrawingObjects().contains(rectangle1)); assertFalse(tree.getDrawingObjects().contains(rectangle2)); assertTrue(tree.getDrawingObjects().contains(rectangle3)); assertTrue(tree.getDrawingObjects().contains(rectangle4)); tree.remove(rectangle3); assertFalse(tree.getDrawingObjects().contains(rectangle1)); assertFalse(tree.getDrawingObjects().contains(rectangle2)); assertFalse(tree.getDrawingObjects().contains(rectangle3)); assertTrue(tree.getDrawingObjects().contains(rectangle4)); tree.remove(rectangle4); assertFalse(tree.getDrawingObjects().contains(rectangle1)); assertFalse(tree.getDrawingObjects().contains(rectangle2)); assertFalse(tree.getDrawingObjects().contains(rectangle3)); assertFalse(tree.getDrawingObjects().contains(rectangle4)); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void add(final DrawingObject d) { if (threadSafe) { synchronized (lock) { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } else { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
@Test public void borderTest() { final Rectangle rectBorderLeft = new Rectangle(upperLeftX, upperLeftY + (height / 2), rectWidth, rectHeight); final Rectangle rectBorderTop = new Rectangle(upperLeftX + (width / 2), upperLeftY, rectWidth, rectHeight); final Rectangle rectBorderRight = new Rectangle(upperLeftX + width - rectWidth, upperLeftY + (height / 2), rectWidth, rectHeight); final Rectangle rectBorderBottom = new Rectangle(upperLeftX + (width / 2), upperLeftY + height - rectHeight, rectWidth, rectHeight); try { tree.add(rectBorderLeft); } catch (final RuntimeException e) { assertTrue(false); } try { tree.add(rectBorderTop); } catch (final RuntimeException e) { assertTrue(false); } try { tree.add(rectBorderRight); } catch (final RuntimeException e) { assertTrue(false); } try { tree.add(rectBorderBottom); } catch (final RuntimeException e) { assertTrue(false); } } @Test public void testAdd() { Set<DrawingObject> set; addAllRectangles(); set = tree.getDrawingObjects(upperLeftQuadrant); assertTrue(set.size() == 1); assertTrue(set.contains(rectangle1)); rectangle1.setPosition(upperRightQuadrant.getLowerLeft()); rectangle1.syncBoundingBoxForce(); set = tree.getDrawingObjects(upperLeftQuadrant); assertTrue(set.size() == 0); assertTrue(!set.contains(rectangle1)); set = tree.getDrawingObjects(upperRightQuadrant); assertTrue(set.size() == 2); assertTrue(set.contains(rectangle1)); assertTrue(set.contains(rectangle2)); rectangle1.setPosition(lowerRightQuadrant.getLowerLeft()); rectangle1.syncBoundingBoxForce(); set = tree.getDrawingObjects(upperRightQuadrant); assertTrue(set.size() == 1); assertTrue(set.contains(rectangle2)); set = tree.getDrawingObjects(lowerRightQuadrant); assertTrue(set.size() == 2); assertTrue(set.contains(rectangle1)); assertTrue(set.contains(rectangle3)); rectangle1.setPosition(lowerLeftQuadrant.getLowerLeft()); rectangle1.syncBoundingBoxForce(); set = tree.getDrawingObjects(lowerRightQuadrant); assertTrue(set.size() == 1); assertTrue(set.contains(rectangle3)); assertTrue(!set.contains(rectangle1)); set = tree.getDrawingObjects(lowerLeftQuadrant); assertTrue(set.size() == 2); assertTrue(set.contains(rectangle1)); assertTrue(set.contains(rectangle4)); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void bringToFront(final DrawingObject dob) { if (threadSafe) { synchronized (lock) { insertionOrder.put(dob, ++insertionOrderLargest); } } else { insertionOrder.put(dob, ++insertionOrderLargest); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
@Test public void testBringToFront() { Set<DrawingObject> set; addAllRectangles(); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[0] == rectangle1); assertTrue(set.toArray()[3] == rectangle4); tree.bringToFront(rectangle1); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[3] == rectangle1); tree.bringToFront(rectangle2); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[3] == rectangle2); tree.bringToFront(rectangle3); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[3] == rectangle3); tree.bringToFront(rectangle4); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[3] == rectangle4); }
JSONArray extends JSONGetter<Integer> implements JSON, List<Object> { @Override public boolean add(Object e) { return this.rawArrayList.add(JSONUtil.wrap(e)); } JSONArray(); JSONArray(JSONTokener x); JSONArray(String source); JSONArray(Object arrayOrCollection); boolean isNull(int index); String join(String separator); @Override Object get(int index); @Override Object getObj(Integer index, Object defaultValue); @Override Object getByExp(String expression); JSONArray put(Object value); JSONArray put(int index, Object value); JSONObject toJSONObject(JSONArray names); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); @Override Iterator<Object> iterator(); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Object e); @Override Object remove(int index); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends Object> c); @Override boolean addAll(int index, Collection<? extends Object> c); @Override boolean removeAll(Collection<?> c); @Override boolean retainAll(Collection<?> c); @Override void clear(); @Override Object set(int index, Object element); @Override void add(int index, Object element); @Override int indexOf(Object o); @Override int lastIndexOf(Object o); @Override ListIterator<Object> listIterator(); @Override ListIterator<Object> listIterator(int index); @Override List<Object> subList(int fromIndex, int toIndex); Object toArray(Class<?> clazz); Object[] toArray(Class<?> arrayClass, boolean ignoreError); }
@Test public void addTest(){ JSONArray array = JSONUtil.createArray(); array.add("value1"); array.add("value2"); array.add("value3"); Assert.assertEquals(array.get(0), "value1"); }
JSONArray extends JSONGetter<Integer> implements JSON, List<Object> { @Override public Object get(int index) { return this.rawArrayList.get(index); } JSONArray(); JSONArray(JSONTokener x); JSONArray(String source); JSONArray(Object arrayOrCollection); boolean isNull(int index); String join(String separator); @Override Object get(int index); @Override Object getObj(Integer index, Object defaultValue); @Override Object getByExp(String expression); JSONArray put(Object value); JSONArray put(int index, Object value); JSONObject toJSONObject(JSONArray names); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); @Override Iterator<Object> iterator(); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Object e); @Override Object remove(int index); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends Object> c); @Override boolean addAll(int index, Collection<? extends Object> c); @Override boolean removeAll(Collection<?> c); @Override boolean retainAll(Collection<?> c); @Override void clear(); @Override Object set(int index, Object element); @Override void add(int index, Object element); @Override int indexOf(Object o); @Override int lastIndexOf(Object o); @Override ListIterator<Object> listIterator(); @Override ListIterator<Object> listIterator(int index); @Override List<Object> subList(int fromIndex, int toIndex); Object toArray(Class<?> clazz); Object[] toArray(Class<?> arrayClass, boolean ignoreError); }
@Test public void parseTest(){ String jsonStr = "[\"value1\", \"value2\", \"value3\"]"; JSONArray array = JSONUtil.parseArray(jsonStr); Assert.assertEquals(array.get(0), "value1"); }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { @Override public void putAll(Map<? extends String, ? extends Object> m) { rawHashMap.putAll(m); } JSONObject(); JSONObject(JSONObject jsonObject, String... names); JSONObject(JSONTokener x); JSONObject(Object source); JSONObject(Object pojo, String[] names); JSONObject(String source); boolean isNull(String key); JSONArray toJSONArray(Collection<String> names); T toBean(Class<T> clazz); T toBean(Class<T> clazz, boolean ignoreError); T toBean(T bean); T toBean(T bean, boolean ignoreError); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Object get(Object key); @Override Object getObj(String key, Object defaultValue); @Override Object getByExp(String expression); @Override JSONObject put(String key, Object value); JSONObject putOnce(String key, Object value); JSONObject putOpt(String key, Object value); @Override void putAll(Map<? extends String, ? extends Object> m); JSONObject accumulate(String key, Object value); JSONObject append(String key, Object value); JSONObject increment(String key); @Override Object remove(Object key); @Override void clear(); @Override Set<String> keySet(); @Override Collection<Object> values(); @Override Set<Entry<String, Object>> entrySet(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); }
@Test public void putAllTest(){ JSONObject json1 = JSONUtil.createObj(); json1.put("a", "value1"); json1.put("b", "value2"); json1.put("c", "value3"); json1.put("d", true); JSONObject json2 = JSONUtil.createObj(); json2.put("a", "value21"); json2.put("b", "value22"); json1.putAll(json2); Assert.assertEquals(json1.get("a"), "value21"); Assert.assertEquals(json1.get("b"), "value22"); Assert.assertEquals(json1.get("c"), "value3"); }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { @Override public Object get(Object key) { return rawHashMap.get(key); } JSONObject(); JSONObject(JSONObject jsonObject, String... names); JSONObject(JSONTokener x); JSONObject(Object source); JSONObject(Object pojo, String[] names); JSONObject(String source); boolean isNull(String key); JSONArray toJSONArray(Collection<String> names); T toBean(Class<T> clazz); T toBean(Class<T> clazz, boolean ignoreError); T toBean(T bean); T toBean(T bean, boolean ignoreError); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Object get(Object key); @Override Object getObj(String key, Object defaultValue); @Override Object getByExp(String expression); @Override JSONObject put(String key, Object value); JSONObject putOnce(String key, Object value); JSONObject putOpt(String key, Object value); @Override void putAll(Map<? extends String, ? extends Object> m); JSONObject accumulate(String key, Object value); JSONObject append(String key, Object value); JSONObject increment(String key); @Override Object remove(Object key); @Override void clear(); @Override Set<String> keySet(); @Override Collection<Object> values(); @Override Set<Entry<String, Object>> entrySet(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); }
@Test public void parseTest(){ String jsonStr = "{\"b\":\"value2\",\"c\":\"value3\",\"a\":\"value1\", \"d\": true}"; JSONObject jsonObject = JSONUtil.parseObj(jsonStr); Assert.assertEquals(jsonObject.get("a"), "value1"); Assert.assertEquals(jsonObject.get("b"), "value2"); Assert.assertEquals(jsonObject.get("c"), "value3"); Assert.assertEquals(jsonObject.get("d"), true); }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { public <T> T toBean(Class<T> clazz) { return toBean(clazz, false); } JSONObject(); JSONObject(JSONObject jsonObject, String... names); JSONObject(JSONTokener x); JSONObject(Object source); JSONObject(Object pojo, String[] names); JSONObject(String source); boolean isNull(String key); JSONArray toJSONArray(Collection<String> names); T toBean(Class<T> clazz); T toBean(Class<T> clazz, boolean ignoreError); T toBean(T bean); T toBean(T bean, boolean ignoreError); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Object get(Object key); @Override Object getObj(String key, Object defaultValue); @Override Object getByExp(String expression); @Override JSONObject put(String key, Object value); JSONObject putOnce(String key, Object value); JSONObject putOpt(String key, Object value); @Override void putAll(Map<? extends String, ? extends Object> m); JSONObject accumulate(String key, Object value); JSONObject append(String key, Object value); JSONObject increment(String key); @Override Object remove(Object key); @Override void clear(); @Override Set<String> keySet(); @Override Collection<Object> values(); @Override Set<Entry<String, Object>> entrySet(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); }
@Test public void toBeanTest(){ JSONObject subJson = JSONUtil.createObj().put("value1", "strValue1").put("value2", "234"); JSONObject json = JSONUtil.createObj() .put("strValue", "strTest") .put("intValue", 123) .put("beanValue", subJson) .put("list", JSONUtil.createArray().put("a").put("b")); TestBean bean = json.toBean(TestBean.class); Console.log(bean); } @Test public void beanTransTest(){ UserA userA = new UserA(); userA.setA("A user"); userA.setName("nameTest"); userA.setDate(new Date()); JSONObject userAJson = JSONUtil.parseObj(userA); UserB userB = JSONUtil.toBean(userAJson, UserB.class); Assert.assertEquals(userA.getName(), userB.getName()); Assert.assertEquals(userA.getDate(), userB.getDate()); }
CassandraLoader implements Loader<DecisionTreeRuleSet>, Persister, ComponentLifecycle { public Result<ChangeSet> getChange(final String changeSetName) { try { final ResultSet resultSet = this.session.execute(CQL_GET_ACTIVE_CHANGE, changeSetName); EhSupport.ensure(!resultSet.isExhausted(), "ChangeSet %s does not exist in %s.", changeSetName, this.keyspace); UUID changeSetId = null; final Map<Change, List<Change>> changes = new HashMap<>(); for (final Row row : resultSet) { changeSetId = row.getUUID("id"); final UUID changeid = row.getUUID("changeid"); final String rulesetname = row.getString("rulesetname"); final Instant activationTime = row.get("activationtime", Instant.class); final DateRange changeRange = new DateRange(row.get("start", Instant.class), row.get("end", Instant.class)); final Change newchange = new Change(changeid, rulesetname, activationTime, changeRange, getAuditForChange(row), getRuleChangeForChange(row), getValueGroupChange(row)); final List<Change> internalChanges = changes.computeIfAbsent(newchange, value -> new ArrayList<>()); internalChanges.add(newchange); } return Result.success(new ChangeSet(changeSetId, changeSetName, mergeChangesIntoSet(changes))); } catch (final Exception exception) { return Result.failure(() -> exception); } } private CassandraLoader(final Cluster cluster, final String keyspace, final String ruleSetName); static CassandraLoader instanceOf(final Cluster cluster, final String keyspace, final String ruleSetName); @Override Result<DecisionTreeRuleSet> get(); @Override void put(final DecisionTreeRuleSet ruleset); void put(final ChangeSet changeSet); Result<ChangeSet> getChange(final String changeSetName); @Override boolean test(final Result result); @Override boolean isRunning(); @Override void stop(); }
@Test public void testGetChange() { setUpPutChangeMocks(false); final CassandraLoader testInstance = CassandraLoader.instanceOf(this.cluster, "keyspace", RULE_SET_NAME); assertNotNull(testInstance); verify(this.cluster, times(1)).getConfiguration(); final Result<ChangeSet> loadedChangeSet = testInstance.getChange(CHANGE_NAME); assertNotNull(loadedChangeSet); if (!loadedChangeSet.isSuccess()) { assertTrue(loadedChangeSet.getException().getMessage(), loadedChangeSet.isSuccess()); } verifyRuleChanges(); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateInputData(final DecisionTreeRule other) { if (other == null || drivers.length != other.drivers.length) { return false; } for (int i = 0; i < drivers.length; i++) { final InputDriver thisValue = drivers[i]; final InputDriver otherValue = other.drivers[i]; if (!thisValue.equals(otherValue)) { return false; } } return true; } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final int INITIAL_WEIGHTED_VALUE; static final Instant EPOCH; static final Instant MAX; }
@Test public void testRuleDuplicateInputCheck() { final DecisionTreeRule rule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null); assertTrue(rule.isDuplicateInputData(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null))); assertFalse(rule.isDuplicateInputData(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input3"), this.outputDriver, null, null))); assertFalse(rule.isDuplicateInputData(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1"), this.outputDriver, null, null))); assertFalse(rule.isDuplicateInputData(null)); assertFalse(rule.isDuplicateInputData(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray(), this.outputDriver, null, null))); assertFalse(rule.isDuplicateInputData(null)); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateEvaluations(final DecisionTreeRule other) { if (other == null || evaluations == null || other.evaluations == null || evaluations.length != other.evaluations.length) { return false; } for (int i = 0; i < evaluations.length; i++) { final InputDriver thisValue = evaluations[i]; final InputDriver otherValue = other.evaluations[i]; if (!thisValue.equals(otherValue)) { return false; } } return true; } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final int INITIAL_WEIGHTED_VALUE; static final Instant EPOCH; static final Instant MAX; }
@Test public void testRuleDuplicateEvaluationCheck() { final DecisionTreeRule rule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), getInputDriverArray("eval1", "eval2"), this.outputDriver, null, null); assertTrue(rule.isDuplicateEvaluations(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), getInputDriverArray("eval1", "eval2"), this.outputDriver, null, null))); assertFalse(rule.isDuplicateEvaluations(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input3"), getInputDriverArray("input1", "input2"), this.outputDriver, null, null))); assertFalse(rule.isDuplicateEvaluations(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), getInputDriverArray("eval1"), this.outputDriver, null, null))); assertFalse(rule.isDuplicateEvaluations(null)); assertFalse(rule.isDuplicateEvaluations(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null))); assertFalse(rule.isDuplicateEvaluations(null)); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateOutputData(final DecisionTreeRule other) { if (other == null || outputs.size() != other.outputs.size()) { return false; } for (final Map.Entry<String, String> entry : outputs.entrySet()) { final String value = other.outputs.get(entry.getKey()); if (!entry.getValue().equals(value)) { return false; } } return true; } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final int INITIAL_WEIGHTED_VALUE; static final Instant EPOCH; static final Instant MAX; }
@Test public void testRuleDuplicateOutputCheck() { final DecisionTreeRule rule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), null, null); assertTrue(rule.isDuplicateOutputData(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), null, null))); assertTrue(rule.isDuplicateOutputData(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input3", "input4"), Collections.singletonMap("outputDriver", "result"), null, null))); assertFalse(rule.isDuplicateOutputData(null)); assertFalse(rule.isDuplicateOutputData(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input3", "input4"), Collections.singletonMap("outputDriver", "result1"), null, null))); assertFalse(rule.isDuplicateOutputData(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input3", "input4"), Collections.singletonMap("outputDriver1", "result1"), null, null))); assertFalse(rule.isDuplicateOutputData( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input3", "input4"), Stream.of(new AbstractMap.SimpleEntry<>("outputDriver", "result1"), new AbstractMap.SimpleEntry<>("outputDriver2", "result2")) .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue)), null, null))); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateDateRange(final DecisionTreeRule other) { return other != null && start.equals(other.start) && end.equals(other.end); } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final int INITIAL_WEIGHTED_VALUE; static final Instant EPOCH; static final Instant MAX; }
@Test public void testDuplicateDateRange() { final Instant startTime = Instant.now().minus(30, ChronoUnit.DAYS); final Instant endTime = Instant.now().plus(180, ChronoUnit.DAYS); final DecisionTreeRule rule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), startTime, endTime); assertFalse(rule.isDuplicateDateRange(null)); assertTrue(rule.isDuplicateDateRange( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), startTime, endTime))); assertTrue(rule.isDuplicateDateRange( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input3", "input4"), Collections.singletonMap("outputDriver2", "result2"), startTime, endTime))); assertFalse(rule.isDuplicateDateRange( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), null, endTime))); assertFalse(rule.isDuplicateDateRange( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), startTime, null))); assertFalse(rule.isDuplicateDateRange( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), Instant.now(), endTime))); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateRule(final DecisionTreeRule other) { if (other == null) { return false; } if (evaluations != null || other.evaluations != null) { return isDuplicateInputData(other) && isDuplicateOutputData(other) && isDuplicateDateRange(other) && isDuplicateEvaluations(other); } return isDuplicateInputData(other) && isDuplicateOutputData(other) && isDuplicateDateRange(other); } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final int INITIAL_WEIGHTED_VALUE; static final Instant EPOCH; static final Instant MAX; }
@Test public void testDuplicateRuleCheck() { final Instant startTime = Instant.now().minus(30, ChronoUnit.DAYS); final Instant endTime = Instant.now().plus(180, ChronoUnit.DAYS); final DecisionTreeRule rule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), startTime, endTime); assertFalse(rule.isDuplicateRule(null)); assertTrue(rule.isDuplicateRule( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), startTime, endTime))); assertFalse(rule.isDuplicateRule( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input3"), Collections.singletonMap("outputDriver", "result"), startTime, endTime))); assertFalse(rule.isDuplicateRule( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result1"), startTime, endTime))); assertFalse(rule.isDuplicateRule( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), startTime, null))); }
DecisionTreeRule implements TreeRule { void replaceDriversFromCache(final DriverCache cache) { for (int i = 0; i < drivers.length; i++) { final InputDriver driver = drivers[i]; InputDriver cachedDriver = cache.get(driver.getValue(), driver.getType()); if (cachedDriver == null) { cache.put(driver); cachedDriver = cache.get(driver.getValue(), driver.getType()); } drivers[i] = cachedDriver; } } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final int INITIAL_WEIGHTED_VALUE; static final Instant EPOCH; static final Instant MAX; }
@Test public void testReplaceDriversFromCache() { final DecisionTreeRule decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), new UUID(0, 2), getInputDriverArray("input1", "input2"), this.outputDriver, null, null); final DriverCache cache = new DriverCache(); cache.put(new StringDriver("input1")); final InputDriver originalDriver1 = decisionTreeRule.getDrivers()[0]; final InputDriver cachedDriver1 = cache.get("input1", InputValueType.STRING); assertFalse(originalDriver1 == cachedDriver1); decisionTreeRule.replaceDriversFromCache(cache); assertTrue(decisionTreeRule.getDrivers()[0] == cachedDriver1); assertEquals(cache.get("input2", InputValueType.STRING), decisionTreeRule.getDrivers()[1]); }
DecisionTreeRuleSet { @Override public int hashCode() { return name.hashCode(); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
@Test public void testEquality() { final List<String> driverNames = Arrays.asList("driver1", "driver2"); final DecisionTreeRuleSet ruleSet = new DecisionTreeRuleSet("TestName", null, driverNames); assertEquals(ruleSet, ruleSet); assertEquals(new DecisionTreeRuleSet("TestName", null, driverNames), ruleSet); assertNotEquals(new DecisionTreeRuleSet("NotTestName", null, driverNames), ruleSet); assertNotEquals(1, ruleSet); assertNotEquals(ruleSet, null); assertEquals(new DecisionTreeRuleSet("TestName", null, driverNames).hashCode(), ruleSet.hashCode()); assertNotEquals(new DecisionTreeRuleSet("NotTestName", null, driverNames).hashCode(), ruleSet.hashCode()); }
DecisionTreeRuleSet { public static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames) { EhSupport.ensureArg(driverNames.size() < 32, "Maximum number of drivers is 31"); return IntStream.range(0, driverNames.size()) .mapToObj(counter -> new WeightedDriver(driverNames.get(counter), 1 << driverNames.size() - counter)) .collect(collectingAndThen(Collectors.toList(), Collections::unmodifiableList)); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
@Test(expected = IllegalArgumentException.class) public void testTooManyDriversToWeightedDrivers() { final List<String> driverNames = IntStream.range(1, 33).mapToObj(String::valueOf).collect(Collectors.toList()); DecisionTreeRuleSet.convertNamesToWeightedDrivers(driverNames); }
DecisionTreeRuleSet { public Set<ValueGroup> getValueGroups() { return groups.values().stream() .collect(collectingAndThen(Collectors.toSet(), Collections::unmodifiableSet)); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
@Test(expected = UnsupportedOperationException.class) public void testingImmutableValueGroups() { final DecisionTreeRuleSet commisssionRuleSet = CommisionRuleSetSupplier.getCommissionRuleSetWithRegex().build(); commisssionRuleSet.getValueGroups().clear(); }
DecisionTreeRuleSet { public List<String> getDriverNames() { return driverNames.stream().map(WeightedDriver::getName) .collect(collectingAndThen(Collectors.toList(), Collections::unmodifiableList)); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
@Test(expected = UnsupportedOperationException.class) public void testingImmutableDrivers() { final DecisionTreeRuleSet commisssionRuleSet = CommisionRuleSetSupplier.getCommissionRuleSetWithRegex().build(); commisssionRuleSet.getDriverNames().clear(); }
Change implements TreeChange { public boolean addRuleChange(final RuleChange change) { EhSupport.ensureArg(change != null, "Cannot add a null rule change"); return this.ruleChanges.add(change); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); UUID getId(); String getRuleSetName(); Instant getActivationTime(); DateRange getChangeRange(); Set<RuleChange> getRuleChanges(); @Override Map<UUID, Optional<TreeRule>> getRules(); @Override Map<UUID, Optional<TreeValueGroup>> getGroups(); Set<ValueGroupChange> getValueGroupChanges(); boolean addRuleChange(final RuleChange change); boolean addRuleChange(final Set<RuleChange> changes); boolean removeRuleChange(final RuleChange change); boolean addValueGroupChange(final ValueGroupChange change); boolean removeValueGroupChange(final ValueGroupChange change); Audit getAudit(); void setAudit(final Audit audit); @Override boolean equals(final Object other); @Override int hashCode(); }
@Test(expected = IllegalArgumentException.class) public void cannotAddNullRuleChange() { testConstruction(); getBean().addRuleChange((RuleChange) null); } @Test public void addRuleChange() { testConstruction(); final Instant start = NOW.minus(Period.ofWeeks(-1)); final Instant end = start.plus(Period.ofWeeks(5)); final InputDriver[] drivers = getInputDriverArray("Test5", "Test6", "Test7"); final Map<String, String> outputs = Collections.singletonMap("outputDriver", "result"); final DecisionTreeRule rule = new DecisionTreeRule(ADDED_ID, new UUID(0, 4), drivers, outputs, start, end); final RuleChange ruleChange = new RuleChange(Type.NEW, rule); getBean().addRuleChange(ruleChange); assertThat(getBean().getRuleChanges(), hasSize(2)); assertThat(getBean().getRuleChanges(), hasItem(ruleChange)); assertThat(getBean().getValueGroupChanges(), hasSize(1)); }
DecisionTreeRuleSet { public List<String> getEvaluationNames() { return Collections.unmodifiableList(evaluationNames); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
@Test(expected = UnsupportedOperationException.class) public void testingImmutableEvaluationNames() { final DecisionTreeRuleSet commisssionRuleSet = CommisionRuleSetSupplier.getCommissionRuleSetWithRegex().build(); commisssionRuleSet.getEvaluationNames().clear(); }
DecisionTreeRuleSet { public List<InputDriver> getDriversByType(final InputValueType type) { return cache.findByInputDriverType(type); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
@Test public void testFindingInputDrivers() { final DecisionTreeRuleSet commisssionRuleSet = CommisionRuleSetSupplier.getCommissionRuleSetWithRegex().build(); List<InputDriver> driversByType = commisssionRuleSet.getDriversByType(InputValueType.STRING); assertNotNull(driversByType); assertEquals(11, driversByType.size()); assertThat(driversByType, IsCollectionContaining.hasItems(new StringDriver("VOICE"), new StringDriver("RATE"), new StringDriver("UK"), new StringDriver("*"), new StringDriver("CME"), new StringDriver("INDEX"), new StringDriver("S&P"), new StringDriver("US"), new StringDriver("ED"), new StringDriver("NDK"))); driversByType = commisssionRuleSet.getDriversByType(InputValueType.REGEX); assertNotNull(driversByType); assertEquals(3, driversByType.size()); assertThat(driversByType, IsCollectionContaining.hasItems(new RegexDriver("AP.?C"), new RegexDriver("C.?E"), new RegexDriver("^[A-Z]{1,2}[A-Z][0-9]{1,2}$"))); }
ValueGroup implements TreeValueGroup { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } final ValueGroup otherGroup = (ValueGroup) other; return getId().equals(otherGroup.getId()) && getName().equals(otherGroup.getName()) && getValues().equals(otherGroup.getValues()) && getRange().equals(otherGroup.getRange()); } ValueGroup(final String name, final List<String> values); ValueGroup(final UUID id, final String name, final List<String> values, final DateRange range); @Override UUID getId(); @Override String getName(); @Override List<String> getValues(); @Override DateRange getRange(); void updateValues(final List<String> amended); void setNewRuleData(final String driverName, final List<UUID> ruleCodes); List<UUID> getRuleCodes(); String getDriverName(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final DateRange DEFAULT_DATE_RANGE; }
@Test public void equalsCorrect() { final UUID uuid = new UUID(0, 1); final DateRange range = new DateRange(NOW, Instant.MAX); final ValueGroup group = new ValueGroup(uuid, "test-group", Arrays.asList("input1", "input2"), range); assertTrue(group.equals(group)); assertFalse(group.equals(null)); assertFalse(group.equals(Integer.parseInt("1"))); ValueGroup other = new ValueGroup(new UUID(0, 1), "test-group", Arrays.asList("input1", "input2"), new DateRange(NOW, Instant.MAX)); assertTrue(group.equals(other)); other = new ValueGroup(new UUID(0, 2), "test-group", Arrays.asList("input1", "input2"), new DateRange(NOW, Instant.MAX)); assertFalse(group.equals(other)); other = new ValueGroup(new UUID(0, 1), "test-group1", Arrays.asList("input1", "input2"), new DateRange(NOW, Instant.MAX)); assertFalse(group.equals(other)); other = new ValueGroup(new UUID(0, 1), "test-group", Arrays.asList("input1"), new DateRange(NOW, Instant.MAX)); assertFalse(group.equals(other)); other = new ValueGroup(new UUID(0, 1), "test-group", Arrays.asList("input1", "input2"), ValueGroup.DEFAULT_DATE_RANGE); assertFalse(group.equals(other)); }
ValueGroup implements TreeValueGroup { @Override public int hashCode() { return getId().hashCode() + getName().hashCode() + getValues().hashCode() + getRange().hashCode(); } ValueGroup(final String name, final List<String> values); ValueGroup(final UUID id, final String name, final List<String> values, final DateRange range); @Override UUID getId(); @Override String getName(); @Override List<String> getValues(); @Override DateRange getRange(); void updateValues(final List<String> amended); void setNewRuleData(final String driverName, final List<UUID> ruleCodes); List<UUID> getRuleCodes(); String getDriverName(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final DateRange DEFAULT_DATE_RANGE; }
@Test public void hashCodeCorrect() { final UUID uuid = new UUID(0, 1); final DateRange range = new DateRange(NOW, Instant.MAX); final ValueGroup group = new ValueGroup(uuid, "test-group", Arrays.asList("input1", "input2"), range); final ValueGroup other = new ValueGroup(new UUID(0, 1), "test-group", Arrays.asList("input1", "input2"), new DateRange(NOW, Instant.MAX)); assertTrue(group.hashCode() == other.hashCode()); }
ValueGroup implements TreeValueGroup { @Override public String toString() { return GroupDriver.VG_PREFIX + getId(); } ValueGroup(final String name, final List<String> values); ValueGroup(final UUID id, final String name, final List<String> values, final DateRange range); @Override UUID getId(); @Override String getName(); @Override List<String> getValues(); @Override DateRange getRange(); void updateValues(final List<String> amended); void setNewRuleData(final String driverName, final List<UUID> ruleCodes); List<UUID> getRuleCodes(); String getDriverName(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final DateRange DEFAULT_DATE_RANGE; }
@Test public void toStringCorrect() { final UUID uuid = new UUID(0, 1); final DateRange range = new DateRange(NOW, Instant.MAX); final ValueGroup group = new ValueGroup(uuid, "test-group", Arrays.asList("input1", "input2"), range); Assert.assertEquals(GroupDriver.VG_PREFIX + new UUID(0, 1), group.toString()); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
@Test public void testRuleSetBuilderFactory() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> instance = RuleSetBuilder.creator(Arrays.asList("input1", "input2", "input3")); assertNotNull(instance); final DecisionTreeRuleSet ruleSet = instance.build(); assertNotNull(ruleSet); assertEquals("", ruleSet.getName()); } @Test public void testRuleSetBuilderFactoryWithName() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> instance = RuleSetBuilder.creator("TestRuleSetName", Arrays.asList("input1", "input2", "input3")); assertNotNull(instance); final DecisionTreeRuleSet ruleSet = instance.build(); assertNotNull(ruleSet); assertEquals("TestRuleSetName", ruleSet.getName()); } @Test public void testConstructingSimpleRuleSet() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> ruleSetBuilder = RuleSetBuilder.creator(Arrays.asList("input1", "input2", "input3")); ruleSetBuilder.with(RuleSetBuilder::setName, "testSimpleRuleSet"); ruleSetBuilder.with(RuleSetBuilder::rule, RuleBuilder.creator() .with(RuleBuilder::setId, new UUID(0, 3)) .with(RuleBuilder::setCode, new UUID(0, 3)) .with(RuleBuilder::input, Arrays.asList("input1", "input2", "input4")) .with(RuleBuilder::output, Collections.singletonList("outputDriver:result"))); final DecisionTreeRuleSet ruleSet = ruleSetBuilder.build(); assertNotNull(ruleSet); assertEquals(1L, ruleSet.getRules().size()); assertEquals("testSimpleRuleSet", ruleSet.getName()); final DecisionTreeRule rule = ruleSet.getRules().get(new UUID(0, 3)); assertNotNull(rule); assertEquals(new UUID(0, 3), rule.getRuleIdentifier()); assertEquals(3, rule.getDrivers().length); assertEquals(Arrays.asList("input1", "input2", "input3"), ruleSet.getDriverNames()); assertEquals("result", rule.getOutputs().get("outputDriver")); } @Test public void testConstructingRuleSetWithEvaluations() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> ruleSetBuilder = RuleSetBuilder.creator(Arrays.asList("input1", "input2", "input3")); ruleSetBuilder.with(RuleSetBuilder::setName, "testSimpleRuleSet"); ruleSetBuilder.with(RuleSetBuilder::setEvaluationNames, Collections.singletonList("Eval1")); ruleSetBuilder.with(RuleSetBuilder::rule, RuleBuilder.creator() .with(RuleBuilder::setId, new UUID(0, 3)) .with(RuleBuilder::setCode, new UUID(0, 3)) .with(RuleBuilder::input, Arrays.asList("input1", "input2", "input4")) .with(RuleBuilder::evaluations, Collections.singletonList("Eval1")) .with(RuleBuilder::output, Collections.singletonList("outputDriver:result"))); final DecisionTreeRuleSet ruleSet = ruleSetBuilder.build(); assertNotNull(ruleSet); assertThat(ruleSet.getRules(), is(notNullValue())); assertThat(ruleSet.getRules().size(), is(1)); assertThat(ruleSet.getName(), is("testSimpleRuleSet")); assertThat(ruleSet.getEvaluationNames(), is(notNullValue())); assertThat(ruleSet.getEvaluationNames(), hasSize(1)); assertThat(ruleSet.getEvaluationNames(), hasItem("Eval1")); final DecisionTreeRule rule = ruleSet.getRules().get(new UUID(0, 3)); assertThat(rule, is(notNullValue())); assertThat(rule.getRuleIdentifier(), is(new UUID(0, 3))); assertThat(Arrays.asList(rule.getDrivers()), hasSize(3)); assertThat(ruleSet.getDriverNames(), contains("input1", "input2", "input3")); assertThat(rule.getEvaluations().isPresent(), is(true)); assertThat(Arrays.asList(rule.getEvaluations().get()), hasItem(new StringDriver("Eval1"))); assertThat(rule.getOutputs().get("outputDriver"), is("result")); } @Test public void testConstructingSimpleRegexRuleSet() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> ruleSetBuilder = RuleSetBuilder.creator(Arrays.asList("input1", "input2", "input3")); ruleSetBuilder.with(RuleSetBuilder::rule, RuleBuilder.creator() .with(RuleBuilder::input, Arrays.asList("input1", "inp.?t2", "input4.*")) .with(RuleBuilder::output, Collections.singletonMap("outputDriver", "result"))); final DecisionTreeRuleSet ruleSet = ruleSetBuilder.build(); assertNotNull(ruleSet); assertEquals(1L, ruleSet.getRules().size()); } @Test public void testConstructingSimpleValueGroupRuleSetWithoutValueGroups() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> ruleSetBuilder = RuleSetBuilder.creator(Arrays.asList("input1", "input2", "input3")); ruleSetBuilder.with(RuleSetBuilder::rule, RuleBuilder.creator() .with(RuleBuilder::input, Arrays.asList("VG:VG1:input1:input2", "VG:VG2:input3:input4", "VG:VG3:input5:input6:VG:VG4:input7:input8")) .with(RuleBuilder::output, Collections.singletonMap("outputDriver", "result"))); final DecisionTreeRuleSet ruleSet = ruleSetBuilder.build(); assertNotNull(ruleSet); assertEquals(1L, ruleSet.getRules().size()); final Set<ValueGroup> groups = ruleSet.getValueGroups(); assertEquals(4, groups.size()); final DriverCache cache = ruleSet.getDriverCache(); final List<InputDriver> drivers = cache.findByInputDriverType(InputValueType.VALUE_GROUP); assertEquals(8, drivers.size()); InputDriver driver = cache.get("VG1", InputValueType.VALUE_GROUP); assertNotNull(driver); assertTrue(driver.evaluate("input1")); assertTrue(driver.evaluate("input2")); driver = cache.get("VG2", InputValueType.VALUE_GROUP); assertTrue(driver.evaluate("input3")); assertTrue(driver.evaluate("input4")); driver = cache.get("VG3", InputValueType.VALUE_GROUP); assertTrue(driver.evaluate("input5")); assertTrue(driver.evaluate("input6")); assertTrue(driver.evaluate("input7")); assertTrue(driver.evaluate("input8")); driver = cache.get("VG4", InputValueType.VALUE_GROUP); assertTrue(driver.evaluate("input7")); assertTrue(driver.evaluate("input8")); } @Test public void constructsValueGroupRuleSetWithSpecifiedGroups() { final Set<ValueGroup> groups = new HashSet<>(4); final UUID vg1 = new UUID(0, 1); final UUID vg2 = new UUID(0, 2); final UUID vg3 = new UUID(0, 3); final UUID vg4 = new UUID(0, 4); ValueGroup group = new ValueGroup(vg1, "VG1", Arrays.asList("input1", "input2"), ValueGroup.DEFAULT_DATE_RANGE); groups.add(group); group = new ValueGroup(vg2, "VG2", Arrays.asList("input3", "input4"), ValueGroup.DEFAULT_DATE_RANGE); groups.add(group); group = new ValueGroup(vg3, "VG3", Arrays.asList(GroupDriver.VG_PREFIX + vg4, "input5", "input6"), ValueGroup.DEFAULT_DATE_RANGE); groups.add(group); group = new ValueGroup(vg4, "VG4", Arrays.asList("input7", "input8"), ValueGroup.DEFAULT_DATE_RANGE); groups.add(group); final Builder<RuleSetBuilder, DecisionTreeRuleSet> ruleSetBuilder = RuleSetBuilder.creator(Arrays.asList("input1", "input2", "input3")); ruleSetBuilder.with(RuleSetBuilder::rule, RuleBuilder.creator() .with(RuleBuilder::input, Arrays.asList(GroupDriver.VG_PREFIX + vg1, GroupDriver.VG_PREFIX + vg2, GroupDriver.VG_PREFIX + vg3)) .with(RuleBuilder::output, Collections.singletonMap("outputDriver", "result"))); ruleSetBuilder.with(RuleSetBuilder::groups, groups); final DecisionTreeRuleSet ruleSet = ruleSetBuilder.build(); assertNotNull(ruleSet); assertEquals(1L, ruleSet.getRules().size()); final DriverCache cache = ruleSet.getDriverCache(); final List<InputDriver> groupDrivers = cache.findByInputDriverType(InputValueType.VALUE_GROUP); assertThat(groupDrivers, hasSize(4)); GroupDriver added = (GroupDriver) groupDrivers.stream().filter(inputDriver -> vg1.toString().equals(inputDriver.getValue())).findFirst().get(); assertNotNull(added); assertThat(Arrays.stream(added.getSubDrivers(false)).map(InputDriver::getValue).collect(Collectors.toList()), containsInAnyOrder("input1", "input2")); assertTrue(added.evaluate("input1")); assertTrue(added.evaluate("input2")); added = (GroupDriver) groupDrivers.stream().filter(inputDriver -> vg2.toString().equals(inputDriver.getValue())).findFirst().get(); assertNotNull(added); assertThat(Arrays.stream(added.getSubDrivers(false)).map(InputDriver::getValue).collect(Collectors.toList()), containsInAnyOrder("input3", "input4")); assertTrue(added.evaluate("input3")); assertTrue(added.evaluate("input4")); added = (GroupDriver) groupDrivers.stream().filter(inputDriver -> vg3.toString().equals(inputDriver.getValue())).findFirst().get(); assertNotNull(added); assertThat(Arrays.stream(added.getSubDrivers(false)).map(InputDriver::getValue).collect(Collectors.toList()), containsInAnyOrder("input5", "input6", vg4.toString())); assertTrue(added.evaluate("input5")); assertTrue(added.evaluate("input6")); assertTrue(added.evaluate("input7")); assertTrue(added.evaluate("input8")); added = (GroupDriver) groupDrivers.stream().filter(inputDriver -> vg4.toString().equals(inputDriver.getValue())).findFirst().get(); assertNotNull(added); assertThat(Arrays.stream(added.getSubDrivers(false)).map(InputDriver::getValue).collect(Collectors.toList()), containsInAnyOrder("input7", "input8")); assertTrue(added.evaluate("input7")); assertTrue(added.evaluate("input8")); }
Change implements TreeChange { public boolean removeRuleChange(final RuleChange change) { return this.ruleChanges.remove(change); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); UUID getId(); String getRuleSetName(); Instant getActivationTime(); DateRange getChangeRange(); Set<RuleChange> getRuleChanges(); @Override Map<UUID, Optional<TreeRule>> getRules(); @Override Map<UUID, Optional<TreeValueGroup>> getGroups(); Set<ValueGroupChange> getValueGroupChanges(); boolean addRuleChange(final RuleChange change); boolean addRuleChange(final Set<RuleChange> changes); boolean removeRuleChange(final RuleChange change); boolean addValueGroupChange(final ValueGroupChange change); boolean removeValueGroupChange(final ValueGroupChange change); Audit getAudit(); void setAudit(final Audit audit); @Override boolean equals(final Object other); @Override int hashCode(); }
@Test public void removeRuleChange() { addRuleChange(); assertThat(getBean().getRuleChanges(), hasSize(2)); final Instant start = NOW.minus(Period.ofWeeks(-1)); final Instant end = start.plus(Period.ofWeeks(5)); final InputDriver[] drivers = getInputDriverArray("Test5", "Test6", "Test7"); final Map<String, String> outputs = Collections.singletonMap("outputDriver", "result"); DecisionTreeRule rule = new DecisionTreeRule(UNKNOWN_ID, new UUID(0, 4), drivers, outputs, start, end); RuleChange ruleChange = new RuleChange(Type.ORIGINAL, rule); getBean().removeRuleChange(ruleChange); assertThat(getBean().getRuleChanges(), hasSize(2)); assertThat(getBean().getValueGroupChanges(), hasSize(1)); rule = new DecisionTreeRule(UNKNOWN_ID, new UUID(0, 4), drivers, outputs, start, end); ruleChange = new RuleChange(Type.ORIGINAL, rule); getBean().removeRuleChange(ruleChange); assertThat(getBean().getRuleChanges(), hasSize(2)); assertThat(getBean().getValueGroupChanges(), hasSize(1)); rule = new DecisionTreeRule(ADDED_ID, new UUID(0, 4), drivers, outputs, start, end); ruleChange = new RuleChange(Type.ORIGINAL, rule); getBean().removeRuleChange(ruleChange); assertThat(getBean().getRuleChanges(), hasSize(2)); assertThat(getBean().getValueGroupChanges(), hasSize(1)); rule = new DecisionTreeRule(ADDED_ID, new UUID(0, 4), drivers, outputs, start, end); ruleChange = new RuleChange(Type.NEW, rule); getBean().removeRuleChange(ruleChange); assertThat(getBean().getRuleChanges(), hasSize(1)); assertThat(getBean().getValueGroupChanges(), hasSize(1)); }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
@Test public void testCreatingBasicValueGroupDriversInCache() { final DriverCache cache = new DriverCache(); final Set<ValueGroup> valueGroups = new HashSet<>(1); final ValueGroup group = new ValueGroup("vg1", Arrays.asList("input1", "input2", "input3")); valueGroups.add(group); RuleSetBuilder.addValueGroupsToDriverCache(cache, valueGroups); assertTrue(cache.contains(GroupDriver.VG_PREFIX + group.getId())); assertTrue(cache.contains("input1")); assertTrue(cache.contains("input2")); assertTrue(cache.contains("input3")); final InputDriver valueGroup = cache.get(group.getId().toString(), InputValueType.VALUE_GROUP); assertTrue(valueGroup.evaluate("input1")); assertTrue(valueGroup.evaluate("input2")); assertTrue(valueGroup.evaluate("input3")); assertFalse(valueGroup.evaluate("input4")); } @Test public void testCreatingValueGroupsOfValueGroupsInCache() { final DriverCache cache = new DriverCache(); final Set<ValueGroup> valueGroups = new HashSet<>(2); final ValueGroup vg11 = new ValueGroup("vg1.1", Arrays.asList("input1.1", "input1.2")); valueGroups.add(vg11); final ValueGroup vg1 = new ValueGroup("vg1", Arrays.asList("input1", "input2", GroupDriver.VG_PREFIX + vg11.getId())); valueGroups.add(vg1); RuleSetBuilder.addValueGroupsToDriverCache(cache, valueGroups); assertTrue(cache.contains(GroupDriver.VG_PREFIX + vg1.getId())); assertTrue(cache.contains(GroupDriver.VG_PREFIX + vg11.getId())); final InputDriver driverVg1 = cache.get(vg1.getId().toString(), InputValueType.VALUE_GROUP); assertTrue(driverVg1.evaluate("input1.1")); assertTrue(driverVg1.evaluate("input1.2")); assertTrue(driverVg1.evaluate("input1")); assertFalse(driverVg1.evaluate("item1.3")); } @Test public void testRecursiveDefinitionsOfSelf() { final DriverCache cache = new DriverCache(); final Set<ValueGroup> valueGroups = new HashSet<>(2); final ValueGroup vg1 = new ValueGroup("vg1", Arrays.asList("input1", "input2", "VG:vg1.1")); valueGroups.add(vg1); final ValueGroup vg11 = new ValueGroup("vg1.1", Arrays.asList("input1.1", "input1.2")); valueGroups.add(vg11); RuleSetBuilder.addValueGroupsToDriverCache(cache, valueGroups); assertTrue(cache.contains(GroupDriver.VG_PREFIX + vg1.getId())); assertTrue(cache.contains(GroupDriver.VG_PREFIX + vg11.getId())); } @Test public void testRecursiveDefinitionsOfParent() { final DriverCache cache = new DriverCache(); final Set<ValueGroup> valueGroups = new HashSet<>(2); final ValueGroup vg1 = new ValueGroup("vg1", Arrays.asList("input1", "input2", "VG:vg1.1")); valueGroups.add(vg1); final ValueGroup vg11 = new ValueGroup("vg1.1", Arrays.asList("input1.1", "input1.2", "VG:vg1")); valueGroups.add(vg11); RuleSetBuilder.addValueGroupsToDriverCache(cache, valueGroups); assertTrue(cache.contains(GroupDriver.VG_PREFIX + vg1.getId())); assertTrue(cache.contains(GroupDriver.VG_PREFIX + vg11.getId())); } @Test public void testSameGroupNameAsStringValue() { final DriverCache cache = new DriverCache(); final Set<ValueGroup> valueGroups = new HashSet<>(2); final ValueGroup group = new ValueGroup("test", Arrays.asList("test", "input1", "input2")); valueGroups.add(group); RuleSetBuilder.addValueGroupsToDriverCache(cache, valueGroups); assertTrue(cache.contains(GroupDriver.VG_PREFIX + group.getId())); assertTrue(cache.contains("test")); final InputDriver testGroup = cache.get(group.getId().toString(), InputValueType.VALUE_GROUP); assertTrue(testGroup.evaluate("test")); }
InputBuilder { public static String regExInput(final String regex) { return RegexDriver.REGEX_PREFIX + ":" + regex; } private InputBuilder(); static String regExInput(final String regex); static String dateRangeInput(final Range<Instant> range); static String integerRangeInput(final Range<Integer> range); }
@Test public void testRegExInput() { assertThat(InputBuilder.regExInput(".RegEx"), is("RE:.RegEx")); }
InputBuilder { public static String dateRangeInput(final Range<Instant> range) { return DateRangeDriver.DR_PREFIX + ":" + range.getStart() + "|" + range.getFinish(); } private InputBuilder(); static String regExInput(final String regex); static String dateRangeInput(final Range<Instant> range); static String integerRangeInput(final Range<Integer> range); }
@Test public void testDateRangeInput() { final String startStr = "2013-03-28T00:00:00Z"; final String endStr = "2015-06-01T10:50:00Z"; final Range<Instant> range = new Range<>(Instant.parse(startStr), Instant.parse(endStr)); assertThat(InputBuilder.dateRangeInput(range), is("DR:" + startStr + "|" + endStr)); }
InputBuilder { public static String integerRangeInput(final Range<Integer> range) { return IntegerRangeDriver.IR_PREFIX + ":" + range.getStart() + "|" + range.getFinish(); } private InputBuilder(); static String regExInput(final String regex); static String dateRangeInput(final Range<Instant> range); static String integerRangeInput(final Range<Integer> range); }
@Test public void testIntegerRangeInput() { assertThat(InputBuilder.integerRangeInput(new Range<>(100, 500)), is("IR:100|500")); }
Change implements TreeChange { public boolean addValueGroupChange(final ValueGroupChange change) { EhSupport.ensureArg(change != null, "Cannot add a null value group change"); return this.valueGroupChanges.add(change); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); UUID getId(); String getRuleSetName(); Instant getActivationTime(); DateRange getChangeRange(); Set<RuleChange> getRuleChanges(); @Override Map<UUID, Optional<TreeRule>> getRules(); @Override Map<UUID, Optional<TreeValueGroup>> getGroups(); Set<ValueGroupChange> getValueGroupChanges(); boolean addRuleChange(final RuleChange change); boolean addRuleChange(final Set<RuleChange> changes); boolean removeRuleChange(final RuleChange change); boolean addValueGroupChange(final ValueGroupChange change); boolean removeValueGroupChange(final ValueGroupChange change); Audit getAudit(); void setAudit(final Audit audit); @Override boolean equals(final Object other); @Override int hashCode(); }
@Test public void addValueGroupChange() { testConstruction(); final Instant start = NOW.minus(Period.ofWeeks(-1)); final Instant end = start.plus(Period.ofWeeks(5)); final DateRange range = new DateRange(start, end); final List<String> drivers = Arrays.asList("Test5", "Test6", "Test7"); final ValueGroup valueGroup = new ValueGroup(ADDED_ID, "TestValueGroup", drivers, range); final ValueGroupChange valueGroupChange = new ValueGroupChange(Type.NEW, valueGroup); final ValueGroup originalValueGroupChanged = new ValueGroup(BASE_ID, "TestValueGroup", Arrays.asList("Test2", "Test3"), range); final ValueGroupChange originalValueGroupChange = new ValueGroupChange(Type.NEW, originalValueGroupChanged); getBean().addValueGroupChange(valueGroupChange); getBean().addValueGroupChange(originalValueGroupChange); assertThat(getBean().getValueGroupChanges(), hasSize(3)); assertThat(getBean().getValueGroupChanges(), hasItems(getBean().getValueGroupChanges().iterator().next(), valueGroupChange, originalValueGroupChange)); assertThat(getBean().getRuleChanges(), hasSize(1)); final Map<UUID, Optional<TreeValueGroup>> groups = getBean().getGroups(); assertNotNull(groups); assertThat(groups.size(), is(2)); assertThat(groups, allOf( hasEntry(BASE_ID, Optional.<TreeValueGroup>of(originalValueGroupChanged)), hasEntry(ADDED_ID, Optional.<TreeValueGroup>of(valueGroup)))); } @Test(expected = IllegalArgumentException.class) public void cannotAddNullValueGroupChange() { testConstruction(); getBean().addValueGroupChange(null); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
@Test public void testBasicConstruction() { final Builder<RuleBuilder, DecisionTreeRule> ruleBuilder = RuleBuilder.creator(); assertNotNull(ruleBuilder); final List<String> testInputs = Arrays.asList("test1", "test2"); ruleBuilder.with(RuleBuilder::input, testInputs); ruleBuilder.with(RuleBuilder::setDriverCount, 2L); ruleBuilder.with(RuleBuilder::setId, new UUID(0, 1)); ruleBuilder.with(RuleBuilder::output, Collections.singletonMap("outputDriver", "result")); final DecisionTreeRule rule = ruleBuilder.build(); assertNotNull(rule); final InputDriver[] derivedInputDrivers = rule.getDrivers(); assertEquals("test1", derivedInputDrivers[0].getValue()); assertEquals(InputValueType.STRING, derivedInputDrivers[0].getType()); assertEquals("test2", derivedInputDrivers[1].getValue()); assertEquals(InputValueType.STRING, derivedInputDrivers[1].getType()); assertEquals(new UUID(0, 1), rule.getRuleIdentifier()); assertFalse(rule.getEvaluations().isPresent()); assertEquals("result", rule.getOutputs().get("outputDriver")); assertEquals(DecisionTreeRule.EPOCH, rule.getStart()); assertEquals(DecisionTreeRule.MAX, rule.getEnd()); } @Test public void testBasicConstructionWithTokenedOutput() { final Builder<RuleBuilder, DecisionTreeRule> ruleBuilder = RuleBuilder.creator(); assertNotNull(ruleBuilder); final List<String> testInputs = Arrays.asList("test1", "test2"); ruleBuilder.with(RuleBuilder::input, testInputs); ruleBuilder.with(RuleBuilder::setDriverCount, 2L); ruleBuilder.with(RuleBuilder::setId, new UUID(0, 3)); ruleBuilder.with(RuleBuilder::output, Collections.singletonList("outputDriver:result")); final DecisionTreeRule rule = ruleBuilder.build(); assertNotNull(rule); final InputDriver[] derivedInputDrivers = rule.getDrivers(); assertEquals("test1", derivedInputDrivers[0].getValue()); assertEquals(InputValueType.STRING, derivedInputDrivers[0].getType()); assertEquals("test2", derivedInputDrivers[1].getValue()); assertEquals(InputValueType.STRING, derivedInputDrivers[1].getType()); assertEquals(new UUID(0, 3), rule.getRuleIdentifier()); assertFalse(rule.getEvaluations().isPresent()); assertEquals("result", rule.getOutputs().get("outputDriver")); assertEquals(DecisionTreeRule.EPOCH, rule.getStart()); assertEquals(DecisionTreeRule.MAX, rule.getEnd()); } @Test public void testBasicConstructionWithRegexTypes() { final Builder<RuleBuilder, DecisionTreeRule> ruleBuilder = RuleBuilder.creator(); assertNotNull(ruleBuilder); final List<String> testInputs = Arrays.asList("te.?t1", "test2.*"); ruleBuilder.with(RuleBuilder::input, testInputs); ruleBuilder.with(RuleBuilder::setDriverCount, 2L); ruleBuilder.with(RuleBuilder::setId, new UUID(0, 1)); ruleBuilder.with(RuleBuilder::output, Collections.singletonMap("outputDriver", "result")); final DecisionTreeRule rule = ruleBuilder.build(); assertNotNull(rule); final InputDriver[] derivedInputDrivers = rule.getDrivers(); assertEquals("te.?t1", derivedInputDrivers[0].getValue()); assertEquals(InputValueType.REGEX, derivedInputDrivers[0].getType()); assertEquals("test2.*", derivedInputDrivers[1].getValue()); assertEquals(InputValueType.REGEX, derivedInputDrivers[1].getType()); assertFalse(rule.getEvaluations().isPresent()); assertEquals(new UUID(0, 1), rule.getRuleIdentifier()); assertEquals("result", rule.getOutputs().get("outputDriver")); assertEquals(DecisionTreeRule.EPOCH, rule.getStart()); assertEquals(DecisionTreeRule.MAX, rule.getEnd()); } @Test public void testBasicConstructionForValueGroups() { final Builder<RuleBuilder, DecisionTreeRule> ruleBuilder = RuleBuilder.creator(); assertNotNull(ruleBuilder); final List<String> testInputs = Arrays.asList("VG:VG1:test1:test2:test3:test4", "VG:VG2:test10:test20:test30:test40:VG:VG3:test50:test9.?:test200.*"); ruleBuilder.with(RuleBuilder::input, testInputs); ruleBuilder.with(RuleBuilder::setDriverCount, 2L); ruleBuilder.with(RuleBuilder::setId, new UUID(0, 1)); ruleBuilder.with(RuleBuilder::output, Collections.singletonMap("outputDriver", "result")); final DecisionTreeRule rule = ruleBuilder.build(); assertNotNull(rule); final InputDriver[] derivedInputDrivers = rule.getDrivers(); assertEquals("VG1", derivedInputDrivers[0].getValue()); assertEquals(InputValueType.VALUE_GROUP, derivedInputDrivers[0].getType()); assertEquals("VG2", derivedInputDrivers[1].getValue()); assertEquals(InputValueType.VALUE_GROUP, derivedInputDrivers[1].getType()); assertEquals(new UUID(0, 1), rule.getRuleIdentifier()); assertEquals("result", rule.getOutputs().get("outputDriver")); assertFalse(rule.getEvaluations().isPresent()); assertEquals(DecisionTreeRule.EPOCH, rule.getStart()); assertEquals(DecisionTreeRule.MAX, rule.getEnd()); } @Test public void testDatedRuleConstruction() { final Instant startTime = Instant.now().minus(1, ChronoUnit.DAYS); final Instant endTime = Instant.now().plus(1, ChronoUnit.DAYS); final DecisionTreeRule rule = RuleBuilder.creator().with(RuleBuilder::input, Arrays.asList("test1", "test2")) .with(RuleBuilder::setDriverCount, 2L) .with(RuleBuilder::setId, new UUID(0, 1)) .with(RuleBuilder::output, Collections.singletonMap("outputDriver", "result")) .with(RuleBuilder::start, startTime) .with(RuleBuilder::end, endTime) .build(); assertNotNull(rule); } @Test public void testConstructionWithEvaluations() { final Builder<RuleBuilder, DecisionTreeRule> ruleBuilder = RuleBuilder.creator(); assertNotNull(ruleBuilder); final List<String> testInputs = Arrays.asList("test1", "test2"); ruleBuilder.with(RuleBuilder::input, testInputs); ruleBuilder.with(RuleBuilder::setDriverCount, 2L); ruleBuilder.with(RuleBuilder::evaluations, Arrays.asList("Eval1", "Eval2")); ruleBuilder.with(RuleBuilder::setId, new UUID(0, 1)); ruleBuilder.with(RuleBuilder::output, Collections.singletonMap("outputDriver", "result")); final DecisionTreeRule rule = ruleBuilder.build(); assertNotNull(rule); assertTrue(rule.getEvaluations().isPresent()); final InputDriver[] derivedEvaluations = rule.getEvaluations().get(); assertEquals("Eval1", derivedEvaluations[0].getValue()); assertEquals(InputValueType.STRING, derivedEvaluations[0].getType()); assertEquals("Eval2", derivedEvaluations[1].getValue()); assertEquals(InputValueType.STRING, derivedEvaluations[1].getType()); assertEquals(new UUID(0, 1), rule.getRuleIdentifier()); assertEquals("result", rule.getOutputs().get("outputDriver")); assertEquals(DecisionTreeRule.EPOCH, rule.getStart()); assertEquals(DecisionTreeRule.MAX, rule.getEnd()); } @Test(expected = IllegalArgumentException.class) public void testIncorrectNumberOfDrivers() { final Builder<RuleBuilder, DecisionTreeRule> ruleBuilder = RuleBuilder.creator(); assertNotNull(ruleBuilder); final List<String> testInputs = Arrays.asList("test1", "test2"); ruleBuilder.with(RuleBuilder::input, testInputs); ruleBuilder.with(RuleBuilder::setDriverCount, 1L); ruleBuilder.build(); } @Test public void testInvalidRuleConstructionIfEmptyInputs() { final Builder<RuleBuilder, DecisionTreeRule> ruleBuilder = RuleBuilder.creator(); assertNotNull(ruleBuilder); assertNull(ruleBuilder.build()); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
@Test public void convertStringToDateRangeDriverAndTestDates() { final DriverCache cache = new DriverCache(); final String testString = "DR:2017-07-04T16:00:00.000Z|2017-07-10T16:00:00.000Z"; final Supplier<InputDriver> rangeSupplier = DomainSerialiser.createInputDriver(testString, cache); final InputDriver dateRangeDriver = rangeSupplier.get(); assertNotNull(dateRangeDriver); assertThat(dateRangeDriver.getType(), is(InputValueType.DATE_RANGE)); assertThat(dateRangeDriver.getValue(), is(testString)); assertThat(dateRangeDriver.evaluate("2017-07-04T16:00:00.000Z"), is(true)); assertThat(dateRangeDriver.evaluate("2017-07-10T16:00:00.000Z"), is(false)); } @Test public void convertStringToIntegerRangeAndTestData() { final DriverCache cache = new DriverCache(); final String testString = "IR:100|12345"; final Supplier<InputDriver> rangeSupplier = DomainSerialiser.createInputDriver(testString, cache); final InputDriver intRangeDriver = rangeSupplier.get(); assertNotNull(intRangeDriver); assertThat(intRangeDriver.getType(), is(InputValueType.INTEGER_RANGE)); assertThat(intRangeDriver.getValue(), is(testString)); assertThat(intRangeDriver.evaluate("123"), is(true)); assertThat(intRangeDriver.evaluate("54321"), is(false)); } @Test public void convertStringToIntegerRangeWithMax() { final DriverCache cache = new DriverCache(); final String testString = "IR:100|"; final Supplier<InputDriver> rangeSupplier = DomainSerialiser.createInputDriver(testString, cache); final InputDriver intRangeDriver = rangeSupplier.get(); assertNotNull(intRangeDriver); assertThat(intRangeDriver.getType(), is(InputValueType.INTEGER_RANGE)); assertThat(intRangeDriver.getValue(), is(testString)); assertThat(intRangeDriver.evaluate("123"), is(true)); final Integer maxInt = new Integer(Integer.MAX_VALUE); assertThat(intRangeDriver.evaluate(maxInt.toString()), is(false)); final Integer almostMaxInt = new Integer(Integer.MAX_VALUE - 1); assertThat(intRangeDriver.evaluate(almostMaxInt.toString()), is(true)); } @Test public void convertStringToIntegerRangeWithMin() { final DriverCache cache = new DriverCache(); final String testString = "IR:|100"; final Supplier<InputDriver> rangeSupplier = DomainSerialiser.createInputDriver(testString, cache); final InputDriver intRangeDriver = rangeSupplier.get(); assertNotNull(intRangeDriver); assertThat(intRangeDriver.getType(), is(InputValueType.INTEGER_RANGE)); assertThat(intRangeDriver.getValue(), is(testString)); assertThat(intRangeDriver.evaluate("12"), is(true)); final Integer minInt = new Integer(Integer.MIN_VALUE); assertThat(intRangeDriver.evaluate(minInt.toString()), is(true)); } @Test(expected = IllegalStateException.class) public void convertStringToIntegerRangeWithMissingDeliminator() { final DriverCache cache = new DriverCache(); final String testString = "IR:1223"; final Supplier<InputDriver> rangeSupplier = DomainSerialiser.createInputDriver(testString, cache); final InputDriver intRangeDriver = rangeSupplier.get(); } @Test (expected = IllegalStateException.class) public void failInvalidStringToDateRangeDriver() { DomainSerialiser.createInputDriver("DR:2017-07-04T16:00:00.000Z2017-07-10T16:00:00.000Z", new DriverCache()).get(); } @Test (expected = DateTimeParseException.class) public void failInvalidDateStringToDateRangeDriver() { DomainSerialiser.createInputDriver("DR:2017-04T16:00:00.000Z|2017-07-10T16:00:00.000Z", new DriverCache()).get(); } @Test public void convertBrokenEmptyStrings() { final DriverCache cache = new DriverCache(); final String testString = "VG:1::"; final Supplier<InputDriver> groupSupplier = DomainSerialiser.createInputDriver(testString, cache); final InputDriver groupDriver = groupSupplier.get(); assertNotNull(groupDriver); final InputDriver[] drivers = ((GroupDriver) groupDriver).getSubDrivers(false); assertEquals(0, drivers.length); } @Test public void convertStringToGroupDriverWithSubGroups() { final DriverCache cache = new DriverCache(); final Supplier<InputDriver> groupSupplier = DomainSerialiser.createInputDriver("VG:TestGroup:Test", cache); final InputDriver groupDriver = groupSupplier.get(); assertNotNull(groupDriver); assertEquals("TestGroup", groupDriver.getValue()); assertEquals(InputValueType.VALUE_GROUP, groupDriver.getType()); assertEquals(groupDriver, cache.get("TestGroup", InputValueType.VALUE_GROUP)); }
DomainSerialiser { public static List<String> convertOutputs(final Map<String, String> outputMap) { return outputMap.entrySet().stream().map( entry -> entry.getKey() + ":" + entry.getValue()).collect(Collectors.toList()); } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
@Test public void testOutputConversion() { final Map<String, String> outputMap = Stream.of(new AbstractMap.SimpleEntry<>("Driver1", "Value1"), new AbstractMap.SimpleEntry<>("Driver2", "Value2"), new AbstractMap.SimpleEntry<>("Driver3", "Value3")) .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue)); assertThat(DomainSerialiser.convertOutputs(outputMap), IsCollectionContaining.hasItems( "Driver1:Value1", "Driver2:Value2", "Driver3:Value3")); } @Test public void testOutputConversionToMap() { final List<String> outputlist = new ArrayList<>(); outputlist.add("Driver1:Value1"); outputlist.add("Driver2:Value2"); outputlist.add("Driver3:Value3"); final Map<String, String> outputMap = DomainSerialiser.convertOutputs(outputlist); assertEquals(3, outputMap.size()); assertThat(outputMap, IsMapContaining.hasEntry("Driver1", "Value1")); assertThat(outputMap, IsMapContaining.hasEntry("Driver2", "Value2")); assertThat(outputMap, IsMapContaining.hasEntry("Driver3", "Value3")); } @Test public void testInvalidOutputConversion() { final List<String> outputlist = new ArrayList<>(); outputlist.add("Driver1:Value1"); outputlist.add("Driver2Value2"); outputlist.add("Driver3:Value3"); final Map<String, String> outputMap = DomainSerialiser.convertOutputs(outputlist); assertEquals(2, outputMap.size()); assertThat(outputMap, IsMapContaining.hasEntry("Driver1", "Value1")); assertThat(outputMap, IsMapContaining.hasEntry("Driver3", "Value3")); }
Change implements TreeChange { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } final Change otherChange = (Change) other; return this.id.equals(otherChange.getId()) && this.ruleSetName.equals(otherChange.getRuleSetName()); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); UUID getId(); String getRuleSetName(); Instant getActivationTime(); DateRange getChangeRange(); Set<RuleChange> getRuleChanges(); @Override Map<UUID, Optional<TreeRule>> getRules(); @Override Map<UUID, Optional<TreeValueGroup>> getGroups(); Set<ValueGroupChange> getValueGroupChanges(); boolean addRuleChange(final RuleChange change); boolean addRuleChange(final Set<RuleChange> changes); boolean removeRuleChange(final RuleChange change); boolean addValueGroupChange(final ValueGroupChange change); boolean removeValueGroupChange(final ValueGroupChange change); Audit getAudit(); void setAudit(final Audit audit); @Override boolean equals(final Object other); @Override int hashCode(); }
@Test public void equalsCorrect() { final Set<RuleChange> ruleChanges = null; final Set<ValueGroupChange> valueGroupChanges = null; final UUID id = new UUID(0, 2); final Instant initiatorTime = NOW; final Instant authoriserTime = initiatorTime.plus(Period.ofWeeks(1)); final Audit audit = new Audit("USER1", initiatorTime, "USER2", authoriserTime); final Change change = new Change(id, "TEST-RULESET", NOW, CHANGE_RANGE, audit, ruleChanges, valueGroupChanges); assertTrue(change.equals(change)); assertFalse(change.equals(null)); assertFalse(change.equals(Boolean.TRUE)); final Audit otherAudit = new Audit("USER1", initiatorTime, "USER2", authoriserTime); Change other = new Change(new UUID(0, 2), "TEST-RULESET", NOW, CHANGE_RANGE, otherAudit, ruleChanges, valueGroupChanges); assertTrue(change.equals(other)); other = new Change(new UUID(0, 1), "TEST-RULESET", NOW, CHANGE_RANGE, otherAudit, ruleChanges, valueGroupChanges); assertFalse(change.equals(other)); other = new Change(id, "TESTING-RULESET", NOW, CHANGE_RANGE, otherAudit, ruleChanges, valueGroupChanges); assertFalse(change.equals(other)); other = new Change(new UUID(0, 1), "TESTING-RULESET", NOW, CHANGE_RANGE, otherAudit, ruleChanges, valueGroupChanges); assertFalse(change.equals(other)); }
DecisionTree { public static DecisionTree instanceOf(final Loader<DecisionTreeRuleSet> loader, final DecisionTreeType type) { final ActionRetrier<DecisionTreeRuleSet> retrier = Retrier.createNonRetrier(); final Result<DecisionTreeRuleSet> result = retrier.run(loader, booleanResult -> false); EhSupport.checkResult(result); return new DecisionTree(loader, type, result.getData()); } protected DecisionTree(final Loader<DecisionTreeRuleSet> loader, final DecisionTreeType type, final DecisionTreeRuleSet decisionTreeRuleSet); static DecisionTree instanceOf(final Loader<DecisionTreeRuleSet> loader, final DecisionTreeType type); Input createInputs(); Input createInputs(final String... searchValues); Input createInputs(final Map<String, String> evaluationsMap, final String... searchValues); Input createInputs(final Instant evaluationDate, final String... searchValues); Optional<OutputResults> getSingleEvaluationFor(final Input input); @Deprecated Optional<OutputResults> getEvaluationFor(final Input input); List<OutputResults> getEvaluationsFor(final Input input); }
@Test public void slicedDecisionTreeEvaluation() { final DecisionTree decisionTree = DecisionTree.instanceOf( new Loader<DecisionTreeRuleSet>() { @Override public boolean test(final Result result) { return false; } @Override public Result<DecisionTreeRuleSet> get() { return Result.success(CommisionRuleSetSupplier.getSlicedRuleSet().build()); } }, DecisionTreeType.SLICED); assertNotNull(decisionTree); testDatedDecisionTree(decisionTree); } @Test public void datedDecisionTreeEvaluation() { final DecisionTree decisionTree = DecisionTree.instanceOf( new Loader<DecisionTreeRuleSet>() { @Override public boolean test(final Result result) { return false; } @Override public Result<DecisionTreeRuleSet> get() { return Result.success(CommisionRuleSetSupplier.getSlicedRuleSet().build()); } }, DecisionTreeType.DATED); assertNotNull(decisionTree); testDatedDecisionTree(decisionTree); }
Change implements TreeChange { @Override public int hashCode() { return this.id.hashCode() + this.ruleSetName.hashCode(); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); UUID getId(); String getRuleSetName(); Instant getActivationTime(); DateRange getChangeRange(); Set<RuleChange> getRuleChanges(); @Override Map<UUID, Optional<TreeRule>> getRules(); @Override Map<UUID, Optional<TreeValueGroup>> getGroups(); Set<ValueGroupChange> getValueGroupChanges(); boolean addRuleChange(final RuleChange change); boolean addRuleChange(final Set<RuleChange> changes); boolean removeRuleChange(final RuleChange change); boolean addValueGroupChange(final ValueGroupChange change); boolean removeValueGroupChange(final ValueGroupChange change); Audit getAudit(); void setAudit(final Audit audit); @Override boolean equals(final Object other); @Override int hashCode(); }
@Test public void hashCodeCorrect() { final Set<RuleChange> ruleChanges = null; final Set<ValueGroupChange> valueGroupChanges = null; final Instant initiatorTime = NOW; final Instant authoriserTime = initiatorTime.plus(Period.ofWeeks(1)); final Audit audit = new Audit("USER1", initiatorTime, "USER2", authoriserTime); final Change change = new Change(new UUID(0, 2), "TEST-RULESET", NOW, CHANGE_RANGE, audit, ruleChanges, valueGroupChanges); final Audit otherAudit = new Audit("USER1", initiatorTime, "USER2", authoriserTime); final Change otherChange = new Change(new UUID(0, 2), "TEST-RULESET", NOW, CHANGE_RANGE, otherAudit, ruleChanges, valueGroupChanges); assertEquals(change.hashCode(), otherChange.hashCode()); }
ValueGroupChange { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } final ValueGroupChange change = (ValueGroupChange) other; return this.type == change.getType() && this.valueGroup.equals(change.getValueGroup()); } ValueGroupChange(final Type type, final ValueGroup valueGroup); Type getType(); ValueGroup getValueGroup(); @Override boolean equals(final Object other); @Override int hashCode(); }
@Test public void testEquals() { final UUID id = new UUID(0, 1); final Instant start = Instant.now().minus(Period.ofWeeks(-1)); final Instant end = start.plus(Period.ofWeeks(5)); final DateRange range = new DateRange(start, end); final List<String> drivers = Arrays.asList("Test1", "Test2", "Test3"); final ValueGroup valueGroup = new ValueGroup(id, "TestValueGroup", drivers, range); final ValueGroupChange change = new ValueGroupChange(Type.NEW, valueGroup); assertTrue(change.equals(change)); assertFalse(change.equals(null)); assertFalse(change.equals(Boolean.TRUE)); ValueGroupChange other = new ValueGroupChange(Type.NEW, valueGroup); assertTrue(change.equals(other)); final ValueGroup otherValueGroup = new ValueGroup(id, "VG:TestOtherValueGroup", drivers, range); other = new ValueGroupChange(Type.NEW, otherValueGroup); assertFalse(change.equals(other)); other = new ValueGroupChange(Type.ORIGINAL, otherValueGroup); assertFalse(change.equals(other)); }
ValueGroupChange { @Override public int hashCode() { return this.type.hashCode() + this.valueGroup.hashCode(); } ValueGroupChange(final Type type, final ValueGroup valueGroup); Type getType(); ValueGroup getValueGroup(); @Override boolean equals(final Object other); @Override int hashCode(); }
@Test public void hashCodeCorrect() { final UUID id = new UUID(0, 1); final Instant start = Instant.now().minus(Period.ofWeeks(-1)); final Instant end = start.plus(Period.ofWeeks(5)); final DateRange range = new DateRange(start, end); final List<String> drivers = Arrays.asList("Test1", "Test2", "Test3"); final ValueGroup valueGroup = new ValueGroup(id, "TestValueGroup", drivers, range); final ValueGroupChange change = new ValueGroupChange(Type.NEW, valueGroup); final ValueGroupChange other = new ValueGroupChange(Type.NEW, valueGroup); assertEquals(change.hashCode(), other.hashCode()); }
RuleChange { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } final RuleChange otherChange = (RuleChange) other; return this.type == otherChange.getType() && this.getRule().equals(otherChange.getRule()); } RuleChange(final Type type, final DecisionTreeRule rule); Type getType(); DecisionTreeRule getRule(); @Override boolean equals(final Object other); @Override int hashCode(); }
@Test public void equalsCorrect() { final Instant start = Instant.now().minus(Period.ofWeeks(-1)); final Instant end = start.plus(Period.ofWeeks(5)); final InputDriver[] drivers = getInputDriverArray("Test1", "Test2", "Test3"); final Map<String, String> outputs = Collections.singletonMap("outputDriver", "result"); final DecisionTreeRule rule = new DecisionTreeRule(new UUID(0, 1), new UUID(0, 2), drivers, outputs, start, end); final RuleChange ruleChange = new RuleChange(Type.ORIGINAL, rule); assertTrue(ruleChange.equals(ruleChange)); assertFalse(ruleChange.equals(null)); assertFalse(ruleChange.equals(Boolean.TRUE)); DecisionTreeRule otherRule = new DecisionTreeRule(new UUID(0, 1), new UUID(0, 2), drivers, outputs, start, end); RuleChange otherChange = new RuleChange(Type.ORIGINAL, otherRule); assertTrue(ruleChange.equals(otherChange)); otherRule = new DecisionTreeRule(new UUID(0, 2), new UUID(0, 2), drivers, outputs, start, end); otherChange = new RuleChange(Type.ORIGINAL, otherRule); assertFalse(ruleChange.equals(otherChange)); }
RuleChange { @Override public int hashCode() { return this.type.hashCode() + this.rule.hashCode(); } RuleChange(final Type type, final DecisionTreeRule rule); Type getType(); DecisionTreeRule getRule(); @Override boolean equals(final Object other); @Override int hashCode(); }
@Test public void hashCodeCorrect() { final Instant start = Instant.now().minus(Period.ofWeeks(-1)); final Instant end = start.plus(Period.ofWeeks(5)); final InputDriver[] drivers = getInputDriverArray("Test1", "Test2", "Test3"); final Map<String, String> outputs = Collections.singletonMap("outputDriver", "result"); final DecisionTreeRule rule = new DecisionTreeRule(new UUID(0, 1), new UUID(0, 2), drivers, outputs, start, end); final RuleChange ruleChange = new RuleChange(Type.ORIGINAL, rule); final DecisionTreeRule otherRule = new DecisionTreeRule(new UUID(0, 1), new UUID(0, 2), drivers, outputs, start, end); final RuleChange otherRuleChange = new RuleChange(Type.ORIGINAL, otherRule); assertEquals(ruleChange.hashCode(), otherRuleChange.hashCode()); }
JsonJacksonParser implements RuleBuilderParser { @Override public DecisionTreeRuleSet parseRuleSet(final InputStream inputStream) { return EhSupport.propagateFn(() -> { try (final JsonParser parser = new JsonFactory().createParser(inputStream)) { EhSupport.ensureArg(parser.nextToken() == JsonToken.START_OBJECT, "InputStream is not valid JSON"); String ruleSetName = ""; final List<String> drivers = new ArrayList<>(); final List<DecisionTreeRule> rules = new ArrayList<>(1); final DriverCache cache = new DriverCache(); final Set<ValueGroup> groups = ConcurrentHashMap.newKeySet(); while (!parser.isClosed()) { final JsonToken token = parser.nextToken(); if (JsonToken.FIELD_NAME.equals(token)) { final String fieldName = parser.getCurrentName(); switch (fieldName) { case "name": parser.nextToken(); ruleSetName = parser.getText(); break; case "drivers": parseArrayOfStrings(parser, drivers); break; case "groups": parseGroups(parser, cache, groups); break; case "rules": parser.nextToken(); while (parser.nextToken() != JsonToken.END_ARRAY) { final DecisionTreeRule rule = parseRule(parser, cache, groups); if (rule != null) { rules.add(rule); } } break; default: break; } } } return new DecisionTreeRuleSet(ruleSetName, rules.stream().collect( Collectors.toMap(DecisionTreeRule::getRuleIdentifier, r -> r)), drivers, Collections.emptyList(), cache, groups); } }); } @Override DecisionTreeRuleSet parseRuleSet(final InputStream inputStream); }
@Test(expected = IllegalArgumentException.class) public void testInvalidJson() { final String invalidJsonStr = " \"name\": \"FNC_CALCULATION_METHOD_RULESET\",\n" + " \"drivers\": [\n" + " \"CALCULATION_METHOD_NAME\"\n" + " ],\n"; new JsonJacksonParser().parseRuleSet(new ByteArrayInputStream(invalidJsonStr.getBytes(StandardCharsets.UTF_8))); } @Test public void parseRuleSetWithMultipleValueGroups() { EhSupport.propagate(() -> { try (final InputStream is = getClass().getClassLoader().getResourceAsStream("commissions.json")) { assertNotNull(is); final DecisionTreeRuleSet deserializedRuleSet = new JsonJacksonParser().parseRuleSet(is); assertNotNull(deserializedRuleSet); assertEquals("commissions", deserializedRuleSet.getName()); assertValueGroups(deserializedRuleSet); assertThat(deserializedRuleSet.getRules().values(), hasSize(7)); final DriverCache cache = deserializedRuleSet.getDriverCache(); assertTrue(cache.contains(GroupDriver.VG_PREFIX + (new UUID(0, 6)).toString())); assertTrue(cache.contains(GroupDriver.VG_PREFIX + (new UUID(0, 7)).toString())); } }); }
ChangeBuilder { public static Builder<ChangeBuilder, Change> creator(final DecisionTreeRuleSet ruleSet) { return Builder.instanceOf(ChangeBuilder.create(ruleSet), ChangeBuilder.validate(), ChangeBuilder::builds); } private ChangeBuilder(final DecisionTreeRuleSet ruleSet); static Builder<ChangeBuilder, Change> creator(final DecisionTreeRuleSet ruleSet); ChangeBuilder ruleChange(final Builder<RuleChangeBuilder, List<RuleChange>> ruleChangeBuilderBuilder); ChangeBuilder valueGroupChange(final Builder<ValueGroupChangeBuilder, List<ValueGroupChange>> valueGroupChangeBuilderBuilder); void setId(final UUID id); ChangeBuilder audit(final Audit audit); ChangeBuilder activation(final Instant activationTime); void changeRange(final DateRange range); }
@Test public void noRuleSet() { final Builder<ChangeBuilder, Change> builder = ChangeBuilder.creator(null); assertNull(builder.build()); } @Test public void createsChangeWithId() { final Builder<ChangeBuilder, Change> builder = ChangeBuilder.creator(this.ruleSet); final UUID changeId = UUID.randomUUID(); builder.with(ChangeBuilder::setId, changeId); final Change change = builder.build(); assertNotNull(change); assertEquals(changeId, change.getId()); } @Test public void createsChangeWithRules() { final Builder<ChangeBuilder, Change> builder = ChangeBuilder.creator(this.ruleSet); builder.with(ChangeBuilder::audit, new Audit("USER1", NOW, "USER2", NOW)); builder.with(ChangeBuilder::changeRange, new DateRange(NOW.plus(Period.ofWeeks(2)), NOW.plus(Period.ofWeeks(4)))); builder.with(ChangeBuilder::activation, NOW); builder.with(ChangeBuilder::ruleChange, RuleChangeBuilder.creator(this.ruleSet, new UUID(0, 2)) .with(RuleChangeBuilder::input, Arrays.asList("VOICE", "CME", "ED", "US", "Rate")) .with(RuleChangeBuilder::output, Collections.singletonMap("Rate", "2.0"))); builder.with(ChangeBuilder::ruleChange, RuleChangeBuilder.creator(this.ruleSet, new UUID(0, 5)) .with(RuleChangeBuilder::input, Arrays.asList("VOICE", "CME", "ED", "UK", "Rate")) .with(RuleChangeBuilder::output, Collections.singletonMap("Rate", "2.1"))); final Change change = builder.build(); assertNotNull(change); assertNotNull(change.getId()); assertEquals("commissions", change.getRuleSetName()); assertEquals(NOW, change.getActivationTime()); assertEquals(new DateRange(NOW.plus(Period.ofWeeks(2)), NOW.plus(Period.ofWeeks(4))), change.getChangeRange()); assertEquals(NOW, change.getActivationTime()); assertTrue((new Audit("USER1", NOW, "USER2", NOW)).equals(change.getAudit())); final Set<RuleChange> ruleChanges = change.getRuleChanges(); assertThat(ruleChanges, hasSize(3)); final Comparator<RuleChange> typeComparator = (first, second) -> { if (first.getType() == Type.ORIGINAL && second.getType() == Type.NEW) { return -1; } else if (first.getType() == second.getType()) { return 0; } return 1; }; final Comparator<RuleChange> startDateComparator = Comparator.comparing(ruleChange -> ruleChange.getRule().getStart()); final Comparator<RuleChange> codeComparator = Comparator.comparing(ruleChange -> ruleChange.getRule().getRuleCode()); final List<RuleChange> changes = ruleChanges.stream().sorted(codeComparator.thenComparing(typeComparator) .thenComparing(startDateComparator)).collect(Collectors.toList()); RuleChange tmp = changes.get(0); assertEquals(Type.ORIGINAL, tmp.getType()); Assert.assertEquals(new UUID(0, 2), tmp.getRule().getRuleCode()); tmp = changes.get(1); assertEquals(Type.NEW, tmp.getType()); Assert.assertEquals(new UUID(0, 2), tmp.getRule().getRuleCode()); tmp = changes.get(2); assertEquals(Type.NEW, tmp.getType()); Assert.assertEquals(new UUID(0, 5), tmp.getRule().getRuleCode()); } @Test public void createsChangeWithValueGroupAndDefaultChangeRange() { final DecisionTreeRuleSet ruleSet = CommisionRuleSetSupplier.getCommisionRuleSet().build(); final Set<ValueGroup> current = ruleSet.getValueGroups(); assertEquals(1, current.size()); final ValueGroup group = current.stream().findFirst().get(); final List<String> drivers = Arrays.asList("CME", "KCBOT"); final Builder<ValueGroupChangeBuilder, List<ValueGroupChange>> valueGroupChangeBuilder = ValueGroupChangeBuilder.creator(group.getName()); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::ruleSet, ruleSet); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::drivers, drivers); final Builder<ChangeBuilder, Change> builder = ChangeBuilder.creator(ruleSet); builder.with(ChangeBuilder::audit, new Audit("USER1", NOW, "USER2", NOW)); builder.with(ChangeBuilder::valueGroupChange, valueGroupChangeBuilder); final Change change = builder.build(); assertNotNull(change); assertNotNull(change.getId()); assertEquals("commissions", change.getRuleSetName()); assertNull(change.getActivationTime()); assertTrue((new Audit("USER1", NOW, "USER2", NOW)).equals(change.getAudit())); final Set<ValueGroupChange> changes = change.getValueGroupChanges(); assertThat(changes, hasSize(3)); final List<ValueGroupChange> newChanges = changes.stream().filter(valueGroupChange -> valueGroupChange.getType() == Type.NEW && valueGroupChange.getValueGroup().getName().equals("CMEGroup")) .collect(Collectors.toList()); assertThat(newChanges, hasSize(2)); assertThat(change.getRuleChanges(), hasSize(3)); final List<RuleChange> ruleCodeChanges = change.getRuleChanges().stream().filter(ruleChange -> ruleChange.getRule().getRuleCode().equals(new UUID(0, 0))) .collect(Collectors.toList()); assertThat(ruleCodeChanges, hasSize(3)); assertThat(ruleCodeChanges.stream().filter(ruleChange -> ruleChange.getType() == Type.ORIGINAL).collect(Collectors.toList()), hasSize(1)); assertThat(ruleCodeChanges.stream().filter(ruleChange -> ruleChange.getType() == Type.NEW).collect(Collectors.toList()), hasSize(2)); } @Test public void createsChangeForExistingGroupsInRuleSet() { this.ruleSet = CommisionRuleSetSupplier.getCommisionRuleSet().build(); final Set<ValueGroup> current = this.ruleSet.getValueGroups(); assertEquals(1, current.size()); final Builder<ValueGroupChangeBuilder, List<ValueGroupChange>> valueGroupChangeBuilder = ValueGroupChangeBuilder.creator("CMEGroup"); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::ruleSet, this.ruleSet); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::changeType, Type.NONE); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::driver, "EXCHANGE"); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::ruleCodes, Arrays.asList(new UUID(0, 2))); final Builder<ChangeBuilder, Change> builder = ChangeBuilder.creator(this.ruleSet); builder.with(ChangeBuilder::audit, new Audit("USER1", NOW, "USER2", NOW)); builder.with(ChangeBuilder::valueGroupChange, valueGroupChangeBuilder); final Change change = builder.build(); assertNotNull(change); assertNotNull(change.getId()); assertEquals("commissions", change.getRuleSetName()); assertNull(change.getActivationTime()); assertTrue((new Audit("USER1", NOW, "USER2", NOW)).equals(change.getAudit())); assertThat(change.getValueGroupChanges(), hasSize(0)); final Set<RuleChange> changes = change.getRuleChanges(); final List<RuleChange> originals = changes.stream().filter(ruleChange -> Type.ORIGINAL == ruleChange.getType()).collect(Collectors.toList()); assertThat(originals, hasSize(1)); final DecisionTreeRule original = originals.get(0).getRule(); assertEquals(new UUID(0, 2), original.getRuleIdentifier()); final List<RuleChange> newRules = changes.stream().filter(ruleChange -> Type.NEW == ruleChange.getType()).collect(Collectors.toList()); assertThat(originals, hasSize(1)); final DecisionTreeRule newRule = newRules.get(0).getRule(); final List<String> drivers = Arrays.stream(newRule.getDrivers()).map(InputDriver::toString) .collect(Collectors.toList()); assertThat(drivers, hasItems("VOICE", GroupDriver.VG_PREFIX + new UUID(0, 1), "ED", "*", "RATE")); } @Test(expected = IllegalStateException.class) public void cannotCreateValueGroupChangeAndRuleChangeForSameRule() { this.ruleSet = CommisionRuleSetSupplier.getCommisionRuleSet().build(); final Set<ValueGroup> current = this.ruleSet.getValueGroups(); final Builder<ChangeBuilder, Change> builder = ChangeBuilder.creator(this.ruleSet); builder.with(ChangeBuilder::audit, new Audit("USER1", NOW, "USER2", NOW)); final Builder<ValueGroupChangeBuilder, List<ValueGroupChange>> valueGroupChangeBuilder = ValueGroupChangeBuilder.creator("CMEGroup"); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::ruleSet, this.ruleSet); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::changeType, Type.NONE); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::driver, "EXCHANGE"); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::ruleCodes, Arrays.asList(new UUID(0, 2))); builder.with(ChangeBuilder::valueGroupChange, valueGroupChangeBuilder); builder.with(ChangeBuilder::ruleChange, RuleChangeBuilder.creator(this.ruleSet, new UUID(0, 2)) .with(RuleChangeBuilder::output, Collections.singletonMap("Rate", "2.0"))); builder.build(); } @Test(expected = IllegalStateException.class) public void cannotCreateMultipleRulesChangeForSameRule() { this.ruleSet = CommisionRuleSetSupplier.getCommisionRuleSet().build(); final Builder<ChangeBuilder, Change> builder = ChangeBuilder.creator(this.ruleSet); builder.with(ChangeBuilder::audit, new Audit("USER1", NOW, "USER2", NOW)); builder.with(ChangeBuilder::ruleChange, RuleChangeBuilder.creator(this.ruleSet, new UUID(0, 2)) .with(RuleChangeBuilder::output, Collections.singletonMap("Rate", "1.2"))); builder.with(ChangeBuilder::ruleChange, RuleChangeBuilder.creator(this.ruleSet, new UUID(0, 2)) .with(RuleChangeBuilder::output, Collections.singletonMap("Rate", "2.1"))); builder.build(); }
RuleGroupChangeBuilder extends BaseBuilder<RuleChange, DecisionTreeRule> { public static Builder<RuleGroupChangeBuilder, List<RuleChange>> creator(final List<ValueGroupChange> groupChanges, final DecisionTreeRuleSet ruleSet) { return Builder.instanceOf(RuleGroupChangeBuilder.create(groupChanges, ruleSet), RuleGroupChangeBuilder::builds); } private RuleGroupChangeBuilder(final List<ValueGroupChange> groupChanges, final DecisionTreeRuleSet ruleSet); static Builder<RuleGroupChangeBuilder, List<RuleChange>> creator(final List<ValueGroupChange> groupChanges, final DecisionTreeRuleSet ruleSet); RuleGroupChangeBuilder driver(final String driver); RuleGroupChangeBuilder ruleCodes(final Set<UUID> ruleCodes); }
@Test(expected = IllegalArgumentException.class) public void failsWithNoValueGroupChanges() { this.builder = RuleGroupChangeBuilder.creator(emptyList(), this.ruleSet); this.builder.build(); } @Test(expected = IllegalArgumentException.class) public void failsWithNoRuleset() { final List<ValueGroupChange> changes = getValueGroupChanges(new DateRange(NOW, NOW.plus(Period.ofWeeks(1))), Arrays.asList("CME", "CBOT", "CBOT"), true); assertEquals(4, changes.size()); this.builder = RuleGroupChangeBuilder.creator(changes, null); this.builder.build(); } @Test public void changeBeforeRuleSegmentsStart() { final List<ValueGroupChange> changes = getValueGroupChanges(new DateRange(NOW, NOW.plus(Period.ofWeeks(1))), Arrays.asList("CME", "CBOT", "CBOT"), false); assertEquals(4, changes.size()); this.builder = RuleGroupChangeBuilder.creator(changes, this.ruleSet); final List<RuleChange> ruleChanges = this.builder.build(); assertEquals(6, ruleChanges.size()); final List<RuleChange> originals = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.ORIGINAL); assertEquals(3, originals.size()); assertOriginalSegmentsRemoved(originals); final List<RuleChange> newChanges = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.NEW); assertEquals(3, newChanges.size()); assertRuleChange(newChanges.get(0), Type.NEW, null, new UUID(0, 2), new String[]{"VOICE", GroupDriver.VG_PREFIX + getUuid(changes, 3), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.1 "), NOW.plus(Period.ofWeeks(2)), NOW.plus(Period.ofWeeks(4))); assertRuleChange(newChanges.get(1), Type.NEW, null, new UUID(0, 2), new String[]{"EMAIL", GroupDriver.VG_PREFIX + getUuid(changes, 3), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.2"), NOW.plus(Period.ofWeeks(4)), NOW.plus(Period.ofWeeks(6))); assertRuleChange(newChanges.get(2), Type.NEW, null, new UUID(0, 2), new String[]{"ELECTRONIC", GroupDriver.VG_PREFIX + getUuid(changes, 3), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.3"), NOW.plus(Period.ofWeeks(6)), NOW.plus(Period.ofWeeks(8))); } @Test public void changeAfterRuleSegmentsFinish() { final List<ValueGroupChange> changes = getValueGroupChanges(new DateRange(NOW.plus(Period.ofWeeks(10)), NOW.plus(Period.ofWeeks(12))), Arrays.asList("CME", "CBOT", "CBOT"), false); assertEquals(4, changes.size()); this.builder = RuleGroupChangeBuilder.creator(changes, this.ruleSet); final List<RuleChange> ruleChanges = this.builder.build(); assertEquals(6, ruleChanges.size()); final List<RuleChange> originals = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.ORIGINAL); assertEquals(3, originals.size()); assertOriginalSegmentsRemoved(originals); final List<RuleChange> newChanges = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.NEW); assertEquals(3, newChanges.size()); assertRuleChange(newChanges.get(0), Type.NEW, null, new UUID(0, 2), new String[]{"VOICE", GroupDriver.VG_PREFIX + getUuid(changes, 1), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.1 "), NOW.plus(Period.ofWeeks(2)), NOW.plus(Period.ofWeeks(4))); assertRuleChange(newChanges.get(1), Type.NEW, null, new UUID(0, 2), new String[]{"EMAIL", GroupDriver.VG_PREFIX + getUuid(changes, 1), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.2"), NOW.plus(Period.ofWeeks(4)), NOW.plus(Period.ofWeeks(6))); assertRuleChange(newChanges.get(2), Type.NEW, null, new UUID(0, 2), new String[]{"ELECTRONIC", GroupDriver.VG_PREFIX + getUuid(changes, 1), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.3"), NOW.plus(Period.ofWeeks(6)), NOW.plus(Period.ofWeeks(8))); } @Test public void valueGroupAmendedForFirstSegment() { final List<ValueGroupChange> changes = getValueGroupChanges(new DateRange(NOW.plus(Period.ofWeeks(2)), NOW.plus(Period.ofWeeks(4))), Arrays.asList("CME", "CBOT", "CBOT"), false); assertEquals(4, changes.size()); this.builder = RuleGroupChangeBuilder.creator(changes, this.ruleSet); final List<RuleChange> ruleChanges = this.builder.build(); assertEquals(6, ruleChanges.size()); final List<RuleChange> originals = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.ORIGINAL); assertEquals(3, originals.size()); assertOriginalSegmentsRemoved(originals); final List<RuleChange> newChanges = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.NEW); assertEquals(3, newChanges.size()); assertRuleChange(newChanges.get(0), Type.NEW, null, new UUID(0, 2), new String[]{"VOICE", GroupDriver.VG_PREFIX + getUuid(changes, 2), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.1 "), NOW.plus(Period.ofWeeks(2)), NOW.plus(Period.ofWeeks(4))); assertRuleChange(newChanges.get(1), Type.NEW, null, new UUID(0, 2), new String[]{"EMAIL", GroupDriver.VG_PREFIX + getUuid(changes, 3), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.2"), NOW.plus(Period.ofWeeks(4)), NOW.plus(Period.ofWeeks(6))); assertRuleChange(newChanges.get(2), Type.NEW, null, new UUID(0, 2), new String[]{"ELECTRONIC", GroupDriver.VG_PREFIX + getUuid(changes, 3), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.3"), NOW.plus(Period.ofWeeks(6)), NOW.plus(Period.ofWeeks(8))); } @Test public void valueGroupAmendedFromBeforeSecondStartToAfterSecondSegmentFinish() { final List<ValueGroupChange> changes = getValueGroupChanges(new DateRange(NOW.plus(Period.ofWeeks(3)), NOW.plus(Period.ofWeeks(7))), Arrays.asList("CME", "CBOT", "CBOT"), false); assertEquals(4, changes.size()); this.builder = RuleGroupChangeBuilder.creator(changes, this.ruleSet); final List<RuleChange> ruleChanges = this.builder.build(); assertEquals(8, ruleChanges.size()); final List<RuleChange> originals = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.ORIGINAL); assertEquals(3, originals.size()); assertOriginalSegmentsRemoved(originals); final List<RuleChange> newChanges = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.NEW); assertEquals(5, newChanges.size()); assertRuleChange(newChanges.get(0), Type.NEW, null, new UUID(0, 2), new String[]{"VOICE", GroupDriver.VG_PREFIX + getUuid(changes, 1), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.1 "), NOW.plus(Period.ofWeeks(2)), NOW.plus(Period.ofWeeks(3))); assertRuleChange(newChanges.get(1), Type.NEW, null, new UUID(0, 2), new String[]{"VOICE", GroupDriver.VG_PREFIX + getUuid(changes, 2), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.1 "), NOW.plus(Period.ofWeeks(3)), NOW.plus(Period.ofWeeks(4))); assertRuleChange(newChanges.get(2), Type.NEW, null, new UUID(0, 2), new String[]{"EMAIL", GroupDriver.VG_PREFIX + getUuid(changes, 2), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.2"), NOW.plus(Period.ofWeeks(4)), NOW.plus(Period.ofWeeks(6))); assertRuleChange(newChanges.get(3), Type.NEW, null, new UUID(0, 2), new String[]{"ELECTRONIC", GroupDriver.VG_PREFIX + getUuid(changes, 2), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.3"), NOW.plus(Period.ofWeeks(6)), NOW.plus(Period.ofWeeks(7))); assertRuleChange(newChanges.get(4), Type.NEW, null, new UUID(0, 2), new String[]{"ELECTRONIC", GroupDriver.VG_PREFIX + getUuid(changes, 3), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.3"), NOW.plus(Period.ofWeeks(7)), NOW.plus(Period.ofWeeks(8))); } @Test public void noChangesWhenRulesNotFoundForRuleCode() { createRuleMapWithSingleRuleAndNoValueGroupsInRule(null); final List<ValueGroupChange> changes = ValueGroupChangeBuilder.creator("CMEGroup") .with(ValueGroupChangeBuilder::ruleSet, this.ruleSet) .with(ValueGroupChangeBuilder::changeRange, ValueGroup.DEFAULT_DATE_RANGE) .with(ValueGroupChangeBuilder::drivers, Arrays.asList("CME", "CBOT", "NYMEX")).build(); assertEquals(1, changes.size()); assertEquals(Type.NEW, changes.get(0).getType()); this.builder = RuleGroupChangeBuilder.creator(changes, this.ruleSet); this.builder.with(RuleGroupChangeBuilder::ruleCodes, singleton(UUID.randomUUID())); this.builder.with(RuleGroupChangeBuilder::driver, "EXCHANGE"); final List<RuleChange> ruleChanges = this.builder.build(); assertTrue(ruleChanges.isEmpty()); } @Test public void noChangesWhenDriverNameNotFound() { createRuleMapWithSingleRuleAndNoValueGroupsInRule(null); final List<ValueGroupChange> changes = ValueGroupChangeBuilder.creator("CMEGroup") .with(ValueGroupChangeBuilder::ruleSet, this.ruleSet) .with(ValueGroupChangeBuilder::changeRange, ValueGroup.DEFAULT_DATE_RANGE) .with(ValueGroupChangeBuilder::drivers, Arrays.asList("CME", "CBOT", "NYMEX")).build(); assertEquals(1, changes.size()); assertEquals(Type.NEW, changes.get(0).getType()); this.builder = RuleGroupChangeBuilder.creator(changes, this.ruleSet); this.builder.with(RuleGroupChangeBuilder::ruleCodes, singleton(RULE_CODE)); this.builder.with(RuleGroupChangeBuilder::driver, "DRIVER_NOT_FOUND"); final List<RuleChange> ruleChanges = this.builder.build(); assertTrue(ruleChanges.isEmpty()); } @Test public void addsNewValueGroupToAllMatchingRules() { createRuleMapWithSingleRuleAndNoValueGroupsInRule(null); final List<ValueGroupChange> changes = ValueGroupChangeBuilder.creator("CMEGroup") .with(ValueGroupChangeBuilder::ruleSet, this.ruleSet) .with(ValueGroupChangeBuilder::changeRange, ValueGroup.DEFAULT_DATE_RANGE) .with(ValueGroupChangeBuilder::drivers, Arrays.asList("CME", "CBOT", "NYMEX")) .with(ValueGroupChangeBuilder::ruleCodes, singletonList(RULE_CODE)) .with(ValueGroupChangeBuilder::driver, "EXCHANGE").build(); assertEquals(1, changes.size()); assertEquals(Type.NEW, changes.get(0).getType()); this.builder = RuleGroupChangeBuilder.creator(changes, this.ruleSet); this.builder.with(RuleGroupChangeBuilder::ruleCodes, singleton(RULE_CODE)); this.builder.with(RuleGroupChangeBuilder::driver, "EXCHANGE"); final List<RuleChange> ruleChanges = this.builder.build(); final List<RuleChange> originals = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.ORIGINAL); assertEquals(3, originals.size()); assertRuleChange(originals.get(0), Type.ORIGINAL, new UUID(0, 1), new UUID(0, 2), new String[]{"VOICE", "CME", "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.1 "), NOW.plus(Period.ofWeeks(2)), NOW.plus(Period.ofWeeks(4))); assertRuleChange(originals.get(1), Type.ORIGINAL, new UUID(0, 2), new UUID(0, 2), new String[]{"EMAIL", "CME", "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.2"), NOW.plus(Period.ofWeeks(4)), NOW.plus(Period.ofWeeks(6))); assertRuleChange(originals.get(2), Type.ORIGINAL, new UUID(0, 3), new UUID(0, 2), new String[]{"ELECTRONIC", "CME", "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.3"), NOW.plus(Period.ofWeeks(6)), NOW.plus(Period.ofWeeks(8))); final List<RuleChange> newChanges = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.NEW); assertEquals(3, newChanges.size()); assertRuleChange(newChanges.get(0), Type.NEW, null, new UUID(0, 2), new String[]{"VOICE", GroupDriver.VG_PREFIX + getUuid(changes, 0), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.1 "), NOW.plus(Period.ofWeeks(2)), NOW.plus(Period.ofWeeks(4))); assertRuleChange(newChanges.get(1), Type.NEW, null, new UUID(0, 2), new String[]{"EMAIL", GroupDriver.VG_PREFIX + getUuid(changes, 0), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.2"), NOW.plus(Period.ofWeeks(4)), NOW.plus(Period.ofWeeks(6))); assertRuleChange(newChanges.get(2), Type.NEW, null, new UUID(0, 2), new String[]{"ELECTRONIC", GroupDriver.VG_PREFIX + getUuid(changes, 0), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.3"), NOW.plus(Period.ofWeeks(6)), NOW.plus(Period.ofWeeks(8))); } @Test public void addsNewValueGroupToAllMatchingRulesMidSecondSegment() { createRuleMapWithSingleRuleAndNoValueGroupsInRule(null); final List<ValueGroupChange> changes = ValueGroupChangeBuilder.creator("CMEGroup") .with(ValueGroupChangeBuilder::ruleSet, this.ruleSet) .with(ValueGroupChangeBuilder::changeRange, new DateRange(NOW.plus(Period.ofWeeks(5)), DecisionTreeRule.MAX)) .with(ValueGroupChangeBuilder::drivers, Arrays.asList("CME", "CBOT", "NYMEX")) .with(ValueGroupChangeBuilder::ruleCodes, singletonList(RULE_CODE)) .with(ValueGroupChangeBuilder::driver, "EXCHANGE").build(); assertEquals(1, changes.size()); assertEquals(Type.NEW, changes.get(0).getType()); this.builder = RuleGroupChangeBuilder.creator(changes, this.ruleSet); this.builder.with(RuleGroupChangeBuilder::ruleCodes, singleton(RULE_CODE)); this.builder.with(RuleGroupChangeBuilder::driver, "EXCHANGE"); final List<RuleChange> ruleChanges = this.builder.build(); final List<RuleChange> originals = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.ORIGINAL); assertEquals(2, originals.size()); assertRuleChange(originals.get(0), Type.ORIGINAL, new UUID(0, 2), new UUID(0, 2), new String[]{"EMAIL", "CME", "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.2"), NOW.plus(Period.ofWeeks(4)), NOW.plus(Period.ofWeeks(6))); assertRuleChange(originals.get(1), Type.ORIGINAL, new UUID(0, 3), new UUID(0, 2), new String[]{"ELECTRONIC", "CME", "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.3"), NOW.plus(Period.ofWeeks(6)), NOW.plus(Period.ofWeeks(8))); final List<RuleChange> newChanges = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.NEW); assertEquals(3, newChanges.size()); assertRuleChange(newChanges.get(0), Type.NEW, null, new UUID(0, 2), new String[]{"EMAIL", "CME", "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.2"), NOW.plus(Period.ofWeeks(4)), NOW.plus(Period.ofWeeks(5))); assertRuleChange(newChanges.get(1), Type.NEW, null, new UUID(0, 2), new String[]{"EMAIL", GroupDriver.VG_PREFIX + getUuid(changes, 0), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.2"), NOW.plus(Period.ofWeeks(5)), NOW.plus(Period.ofWeeks(6))); assertRuleChange(newChanges.get(2), Type.NEW, null, new UUID(0, 2), new String[]{"ELECTRONIC", GroupDriver.VG_PREFIX + getUuid(changes, 0), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.3"), NOW.plus(Period.ofWeeks(6)), NOW.plus(Period.ofWeeks(8))); } @Test public void addsNewValueGroupToAllMatchingRulesAndMergesRules() { createRuleMapWithSingleRuleAndNoValueGroupsForMerge(); final List<ValueGroupChange> changes = ValueGroupChangeBuilder.creator("CMEGroup") .with(ValueGroupChangeBuilder::ruleSet, this.ruleSet) .with(ValueGroupChangeBuilder::changeRange, ValueGroup.DEFAULT_DATE_RANGE) .with(ValueGroupChangeBuilder::drivers, Arrays.asList("CME", "CBOT", "NYMEX")) .with(ValueGroupChangeBuilder::ruleCodes, singletonList(RULE_CODE)) .with(ValueGroupChangeBuilder::driver, "EXCHANGE").build(); assertEquals(1, changes.size()); assertEquals(Type.NEW, changes.get(0).getType()); this.builder = RuleGroupChangeBuilder.creator(changes, this.ruleSet); updateBuilderFromFromValueGroup(changes.get(0).getValueGroup()); final List<RuleChange> ruleChanges = this.builder.build(); final List<RuleChange> originals = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.ORIGINAL); assertEquals(3, originals.size()); assertRuleChange(originals.get(0), Type.ORIGINAL, new UUID(0, 1), new UUID(0, 2), new String[]{"VOICE", "CME", "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.1 "), NOW.plus(Period.ofWeeks(2)), NOW.plus(Period.ofWeeks(4))); assertRuleChange(originals.get(1), Type.ORIGINAL, new UUID(0, 2), new UUID(0, 2), new String[]{"VOICE", "CBOT", "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.1 "), NOW.plus(Period.ofWeeks(4)), NOW.plus(Period.ofWeeks(6))); assertRuleChange(originals.get(2), Type.ORIGINAL, new UUID(0, 3), new UUID(0, 2), new String[]{"VOICE", "CBOT", "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.1 "), NOW.plus(Period.ofWeeks(6)), NOW.plus(Period.ofWeeks(8))); final List<RuleChange> newChanges = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.NEW); assertEquals(1, newChanges.size()); assertRuleChange(newChanges.get(0), Type.NEW, null, new UUID(0, 2), new String[]{"VOICE", GroupDriver.VG_PREFIX + getUuid(changes, 0), "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.1 "), NOW.plus(Period.ofWeeks(2)), NOW.plus(Period.ofWeeks(8))); } @Test public void confirmsRemovalOfValueGroup() { final Set<ValueGroup> groups = new HashSet<>(); groups.add(DEFAULT_VALUE_GROUP); groups.add(new ValueGroup(new UUID(10, 10), "CMEGroup", Arrays.asList("CME", "CBOT", "NYMEX"), ValueGroup.DEFAULT_DATE_RANGE)); createRuleMapWithSingleRuleAndValueGroup(groups); final Builder<ValueGroupChangeBuilder, List<ValueGroupChange>> valueGroupChangeBuilder = ValueGroupChangeBuilder.creator("CMEGroup"); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::ruleSet, this.ruleSet); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::id, new UUID(10, 10)); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::changeRange, new DateRange(null, null)); final List<ValueGroupChange> changes = valueGroupChangeBuilder.build(); assertThat(changes.size(), is(1)); assertThat(changes.get(0).getType(), is(Type.ORIGINAL)); assertEquals(new UUID(10, 10), changes.get(0).getValueGroup().getId()); this.builder = RuleGroupChangeBuilder.creator(changes, this.ruleSet); final List<RuleChange> ruleChanges = this.builder.build(); assertTrue(ruleChanges.isEmpty()); } @Test(expected = IllegalStateException.class) public void cannotRemoveActiveValueGroup() { final Set<ValueGroup> groups = new HashSet<>(); groups.add(DEFAULT_VALUE_GROUP); groups.add(new ValueGroup(new UUID(10, 10), "CME", Arrays.asList("CME", "CBOT", "NYMEX"), ValueGroup.DEFAULT_DATE_RANGE)); createRuleMapWithSingleRuleAndValueGroup(groups); final List<ValueGroupChange> changes = singletonList(new ValueGroupChange(Type.ORIGINAL, new ValueGroup(GROUP_ID, "CME", Arrays.asList("CME", "CBOT"), ValueGroup.DEFAULT_DATE_RANGE))); this.builder = RuleGroupChangeBuilder.creator(changes, this.ruleSet); this.builder.build(); } @Test public void addsExistingValueGroupToAllMatchingRules() { createRuleMapWithSingleRuleAndNoValueGroupsInRule(Collections.singleton(DEFAULT_VALUE_GROUP)); final List<ValueGroupChange> changes = ValueGroupChangeBuilder.creator("CMEGroup") .with(ValueGroupChangeBuilder::ruleSet, this.ruleSet) .with(ValueGroupChangeBuilder::changeType, Type.NONE) .with(ValueGroupChangeBuilder::driver, "EXCHANGE") .with(ValueGroupChangeBuilder::ruleCodes, Arrays.asList(RULE_CODE)).build(); assertThat(changes.size(), is(1)); assertEquals(Type.NONE, changes.get(0).getType()); this.builder = RuleGroupChangeBuilder.creator(changes, this.ruleSet); this.builder.with(RuleGroupChangeBuilder::ruleCodes, singleton(RULE_CODE)); this.builder.with(RuleGroupChangeBuilder::driver, "EXCHANGE"); final List<RuleChange> ruleChanges = this.builder.build(); final List<RuleChange> originals = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.ORIGINAL); assertEquals(3, originals.size()); assertRuleChange(originals.get(0), Type.ORIGINAL, new UUID(0, 1), new UUID(0, 2), new String[]{"VOICE", "CME", "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.1 "), NOW.plus(Period.ofWeeks(2)), NOW.plus(Period.ofWeeks(4))); assertRuleChange(originals.get(1), Type.ORIGINAL, new UUID(0, 2), new UUID(0, 2), new String[]{"EMAIL", "CME", "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.2"), NOW.plus(Period.ofWeeks(4)), NOW.plus(Period.ofWeeks(6))); assertRuleChange(originals.get(2), Type.ORIGINAL, new UUID(0, 3), new UUID(0, 2), new String[]{"ELECTRONIC", "CME", "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.3"), NOW.plus(Period.ofWeeks(6)), NOW.plus(Period.ofWeeks(8))); final List<RuleChange> newChanges = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.NEW); assertEquals(3, newChanges.size()); assertRuleChange(newChanges.get(0), Type.NEW, null, new UUID(0, 2), new String[]{"VOICE", GroupDriver.VG_PREFIX + GROUP_ID, "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.1 "), NOW.plus(Period.ofWeeks(2)), NOW.plus(Period.ofWeeks(4))); assertRuleChange(newChanges.get(1), Type.NEW, null, new UUID(0, 2), new String[]{"EMAIL", GroupDriver.VG_PREFIX + GROUP_ID, "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.2"), NOW.plus(Period.ofWeeks(4)), NOW.plus(Period.ofWeeks(6))); assertRuleChange(newChanges.get(2), Type.NEW, null, new UUID(0, 2), new String[]{"ELECTRONIC", GroupDriver.VG_PREFIX + GROUP_ID, "ED", "US", "INDEX"}, Collections.singletonMap("Rate1", "1.3"), NOW.plus(Period.ofWeeks(6)), NOW.plus(Period.ofWeeks(8))); } @Test public void willNotAddExistingValueGroupToAllMatchingRulesWithOutRuleInformation() { createRuleMapWithSingleRuleAndValueGroup(singleton(DEFAULT_VALUE_GROUP)); final Builder<ValueGroupChangeBuilder, List<ValueGroupChange>> valueGroupChangeBuilder = ValueGroupChangeBuilder.creator("CMEGroup"); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::ruleSet, this.ruleSet); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::changeType, Type.NONE); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::driver, "EXCHANGE"); valueGroupChangeBuilder.with(ValueGroupChangeBuilder::ruleCodes, Arrays.asList(RULE_CODE)); final List<ValueGroupChange> changes = valueGroupChangeBuilder.build(); assertEquals(1, changes.size()); assertEquals(Type.NONE, changes.get(0).getType()); this.builder = RuleGroupChangeBuilder.creator(changes, this.ruleSet); this.builder.with(RuleGroupChangeBuilder::ruleCodes, Collections.emptySet()); final List<RuleChange> ruleChanges = this.builder.build(); final List<RuleChange> originals = RuleChangeBuilderTest.getChangesByType(ruleChanges, Type.ORIGINAL); assertEquals(0, originals.size()); }
JsonJacksonSerialiser implements RuleBuilderSerialiser { @Override public void serialiseRuleSet(final OutputStream outputStream, final DecisionTreeRuleSet decisionTreeRuleSet) { toJsonWriter(outputStream, decisionTreeRuleSet); } static void toJsonWriter(final OutputStream out, final DecisionTreeRuleSet ruleSet); @Override void serialiseRuleSet(final OutputStream outputStream, final DecisionTreeRuleSet decisionTreeRuleSet); }
@Test public void testJsonGenerationWithNonUuidValueGroups() throws IOException { final DecisionTreeRuleSet originalRuleSet = CommisionRuleSetSupplier.getCommisionRuleSet().build(); assertNotNull(originalRuleSet); assertNotNull(originalRuleSet.getRules()); assertNotNull(originalRuleSet.getValueGroups()); final ByteArrayOutputStream stream = new ByteArrayOutputStream(); new JsonJacksonSerialiser().serialiseRuleSet(stream, originalRuleSet); final String jsonString = stream.toString("UTF-8"); assertNotNull(jsonString); LOGGER.debug("JsonString is \n{}", jsonString); final JsonJacksonParser parser = new JsonJacksonParser(); final DecisionTreeRuleSet serialisedRuleSet = parser.parseRuleSet( new ByteArrayInputStream(jsonString.getBytes(StandardCharsets.UTF_8))); assertNotNull(serialisedRuleSet); assertNotNull(serialisedRuleSet.getRules()); assertThat(serialisedRuleSet.getValueGroups().size(), equalTo(originalRuleSet.getValueGroups().size())); assertThat(serialisedRuleSet.getValueGroups().stream().findFirst().get(), equalTo(originalRuleSet.getValueGroups().stream().findFirst().get())); assertThat(serialisedRuleSet.getDriversByType(InputValueType.STRING), IsCollectionContaining.hasItems(originalRuleSet.getDriversByType(InputValueType.STRING) .toArray(new InputDriver[originalRuleSet.getDriversByType(InputValueType.STRING) .size()]))); assertThat(serialisedRuleSet.getDriversByType(InputValueType.REGEX), IsCollectionContaining.hasItems(originalRuleSet.getDriversByType(InputValueType.REGEX) .toArray(new InputDriver[originalRuleSet.getDriversByType(InputValueType.REGEX) .size()]))); for (final DecisionTreeRule rule : originalRuleSet.getRules().values()) { if (Arrays.stream(rule.getDrivers()).noneMatch(inputDriver -> InputValueType.VALUE_GROUP == inputDriver.getType())) { assertThat(rule, DecisionTreeRuleMatcher.isSame( serialisedRuleSet.getRules().get(rule.getRuleIdentifier()))); } else { final DecisionTreeRule other = serialisedRuleSet.getRules().get(rule.getRuleIdentifier()); final InputDriver[] drivers = rule.getDrivers(); final InputDriver[] otherDrivers = other.getDrivers(); for (int i = 0; i < drivers.length; ++i) { final InputDriver driver = drivers[i]; if (InputValueType.VALUE_GROUP == driver.getType()) { final ValueGroup group = serialisedRuleSet.getValueGroups().stream().findFirst().get(); assertNotNull(group); assertThat(driver.getValue(), equalTo(group.getId().toString())); } else { assertThat(driver, equalTo(otherDrivers[i])); } } } } } @Test public void testJsonGenerationForUuidFormattedValueGroups() throws IOException { final Result<DecisionTreeRuleSet> result = FileLoader.jsonLoader("", "commissions", new JsonJacksonParser()) .get(); assertNotNull(result); Assert.assertTrue(result.isSuccess()); final DecisionTreeRuleSet originalRuleSet = result.getData(); final ByteArrayOutputStream stream = new ByteArrayOutputStream(); new JsonJacksonSerialiser().serialiseRuleSet(stream, originalRuleSet); final String jsonString = stream.toString("UTF-8"); assertNotNull(jsonString); LOGGER.debug("JsonString is \n{}", jsonString); final JsonJacksonParser parser = new JsonJacksonParser(); final DecisionTreeRuleSet serialisedRuleSet = parser.parseRuleSet( new ByteArrayInputStream(jsonString.getBytes(StandardCharsets.UTF_8))); assertNotNull(serialisedRuleSet); assertNotNull(serialisedRuleSet.getRules()); assertThat(serialisedRuleSet.getDriversByType(InputValueType.VALUE_GROUP), IsCollectionContaining.hasItems(originalRuleSet.getDriversByType(InputValueType.VALUE_GROUP) .toArray(new InputDriver[originalRuleSet.getDriversByType(InputValueType.VALUE_GROUP) .size()]))); assertThat(serialisedRuleSet.getDriversByType(InputValueType.STRING), IsCollectionContaining.hasItems(originalRuleSet.getDriversByType(InputValueType.STRING) .toArray(new InputDriver[originalRuleSet.getDriversByType(InputValueType.STRING) .size()]))); assertThat(serialisedRuleSet.getDriversByType(InputValueType.REGEX), IsCollectionContaining.hasItems(originalRuleSet.getDriversByType(InputValueType.REGEX) .toArray(new InputDriver[originalRuleSet.getDriversByType(InputValueType.REGEX) .size()]))); for (final DecisionTreeRule rule : originalRuleSet.getRules().values()) { assertThat(rule, DecisionTreeRuleMatcher.isSame( serialisedRuleSet.getRules().get(rule.getRuleIdentifier()))); } } @Ignore @Test public void testJsonWriteToFile() throws IOException { final DecisionTreeRuleSet ruleSet = CommisionRuleSetSupplier.getCommisionRuleSet().build(); try (final OutputStream stream = Files.newOutputStream(Paths.get("COMMISSIONS.zip"), StandardOpenOption.CREATE); final CheckedOutputStream checksum = new CheckedOutputStream(stream, new CRC32()); final ZipOutputStream zipOutputStream = new ZipOutputStream(checksum)) { final ZipEntry entry = new ZipEntry(ruleSet.getName() + ".json"); zipOutputStream.putNextEntry(entry); new JsonJacksonSerialiser().serialiseRuleSet(zipOutputStream, ruleSet); } }
RuleChangeBuilder extends DomainBuilder<RuleChange, DecisionTreeRule> { public static Builder<RuleChangeBuilder, List<RuleChange>> creator(final UUID ruleCode) { return Builder.instanceOf(RuleChangeBuilder.create(ruleCode), RuleChangeBuilder.validate(), RuleChangeBuilder::builds); } private RuleChangeBuilder(final UUID ruleCode); static Builder<RuleChangeBuilder, List<RuleChange>> creator(final UUID ruleCode); static Builder<RuleChangeBuilder, List<RuleChange>> creator(final DecisionTreeRuleSet ruleSet, final UUID ruleCode); RuleChangeBuilder input(final List<String> drivers); RuleChangeBuilder output(final Map<String, String> outputs); RuleChangeBuilder output(final List<String> outputs); RuleChangeBuilder changeRange(final DateRange range); RuleChangeBuilder ruleSet(final DecisionTreeRuleSet ruleSet); RuleChangeBuilder ruleId(final UUID id); }
@Test public void createsNewRule() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> ruleSetBuilder = getRuleSetBuilder(); final DriverCache cache = new DriverCache(); final Set<ValueGroup> groups = ConcurrentHashMap.newKeySet(); final ValueGroup group = new ValueGroup("CMEGroup", Arrays.asList("CME", "CBOT")); groups.add(group); RuleSetBuilder.addValueGroupsToDriverCache(cache, groups); ruleSetBuilder.with(RuleSetBuilder::setCache, cache); ruleSetBuilder.with(RuleSetBuilder::groups, groups); this.ruleSet = ruleSetBuilder.build(); this.builder = RuleChangeBuilder.creator(this.ruleSet, new UUID(0, 9)); this.builder.with(RuleChangeBuilder::input, Arrays.asList("VOICE", "CME", "ED", "UK", GroupDriver.VG_PREFIX + group.getId())); this.builder.with(RuleChangeBuilder::output, Collections.singletonMap("Rate", "2.0")); this.builder.with(RuleChangeBuilder::changeRange, new DateRange(NOW.minus(Period.ofWeeks(1)), NOW.plus(Period.ofWeeks(1)))); final List<RuleChange> ruleChanges = this.builder.build(); assertThat(ruleChanges, hasSize(1)); final RuleChange change = ruleChanges.get(0); assertEquals(Type.NEW, change.getType()); assertRuleChange(change, Type.NEW, null, new UUID(0, 9), new String[]{"VOICE", "CME", "ED", "UK", GroupDriver.VG_PREFIX + group.getId().toString()}, Collections.singletonMap("Rate", "2.0"), NOW.minus(Period.ofWeeks(1)), NOW.plus(Period.ofWeeks(1))); final List<String> driverValues = Arrays.stream(change.getRule().getDrivers()).map(InputDriver::toString).collect(Collectors.toList()); assertThat(driverValues, contains("VOICE", "CME", "ED", "UK", GroupDriver.VG_PREFIX + group.getId())); } @Test(expected = IllegalStateException.class) public void cannotCreateNewRuleWithoutDrivers() { this.ruleSet = getRuleSetBuilder().build(); this.builder = RuleChangeBuilder.creator(this.ruleSet, new UUID(0, 9)); this.builder.with(RuleChangeBuilder::output, Collections.singletonMap("Rate", "2.0")); this.builder.with(RuleChangeBuilder::changeRange, new DateRange(NOW.minus(Period.ofWeeks(1)), NOW.plus(Period.ofWeeks(1)))); this.builder.build(); } @Test(expected = IllegalStateException.class) public void cannotCreateNewRuleWithoutOutputs() { this.ruleSet = getRuleSetBuilder().build(); this.builder = RuleChangeBuilder.creator(this.ruleSet, new UUID(0, 9)); this.builder.with(RuleChangeBuilder::input, Arrays.asList("VOICE", "CME", "ED", "UK", "INDEX")); this.builder.with(RuleChangeBuilder::changeRange, new DateRange(NOW.minus(Period.ofWeeks(1)), NOW.plus(Period.ofWeeks(1)))); this.builder.build(); }
ChangeSetBuilder { public static Builder<ChangeSetBuilder, ChangeSet> creator(final String name) { return Builder.instanceOf(ChangeSetBuilder.create(name), ChangeSetBuilder.validate(), ChangeSetBuilder::builds); } private ChangeSetBuilder(final String name); static Builder<ChangeSetBuilder, ChangeSet> creator(final String name); ChangeSetBuilder change(final Change change); ChangeSetBuilder changes(final Collection<Change> changes); }
@Test(expected = IllegalArgumentException.class) public void cannotBuildWithoutName() { final Builder<ChangeSetBuilder, ChangeSet> builder = ChangeSetBuilder.creator(null); builder.build(); } @Test(expected = IllegalArgumentException.class) public void cannotBuildWithBlankName() { final Builder<ChangeSetBuilder, ChangeSet> builder = ChangeSetBuilder.creator(" "); builder.build(); } @Test public void cannotBuildWithoutChanges() { final Builder<ChangeSetBuilder, ChangeSet> builder = ChangeSetBuilder.creator("TestChangeSet"); assertNull(builder.build()); } @Test public void noChangesWhenNullChangeAdded() { final Builder<ChangeSetBuilder, ChangeSet> builder = ChangeSetBuilder.creator("TestChangeSet"); builder.with(ChangeSetBuilder::change, null); assertNull(builder.build()); } @Test public void noChangesWhenCollectionIsNull() { final Builder<ChangeSetBuilder, ChangeSet> builder = ChangeSetBuilder.creator("TestChangeSet"); builder.with(ChangeSetBuilder::changes, null); assertNull(builder.build()); } @Test public void createsChangeSetContainingSingleChange() { final Builder<ChangeSetBuilder, ChangeSet> builder = ChangeSetBuilder.creator("TestChangeSet"); final Change change = new Change(UUID.randomUUID(), "TestRuleSet", null, null, null, null, null); builder.with(ChangeSetBuilder::change, change); final ChangeSet changeSet = builder.build(); assertNotNull(changeSet.getId()); assertThat(changeSet.getName(), is("TestChangeSet")); assertThat(changeSet.getChanges().size(), is(1)); assertTrue(changeSet.getChanges().contains(change)); } @Test public void createsChangeSetWithChangeCollection() { final Builder<ChangeSetBuilder, ChangeSet> builder = ChangeSetBuilder.creator("TestChangeSet"); final Change first = new Change(UUID.randomUUID(), "FirstTestRuleSet", null, null, null, null, null); final Change second = new Change(UUID.randomUUID(), "SecondTestRuleSet", null, null, null, null, null); final Set<Change> changes = new HashSet<>(); changes.add(first); changes.add(second); builder.with(ChangeSetBuilder::changes, changes); final ChangeSet changeSet = builder.build(); assertNotNull(changeSet.getId()); assertThat(changeSet.getName(), is("TestChangeSet")); assertThat(changeSet.getChanges().size(), is(2)); assertTrue(changeSet.getChanges().contains(first)); assertTrue(changeSet.getChanges().contains(second)); } @Test public void createOutputChangeToCommissionsUkRuleFromToday() { final Builder<ChangeBuilder, Change> changeBuilder = ChangeBuilder.creator(this.commissionRuleSet) .with(ChangeBuilder::ruleChange, RuleChangeBuilder.creator(new UUID(0L, 5)) .with(RuleChangeBuilder::output, Arrays.asList("Rate:1.1", "Unit:£"))); final ChangeSet changeSet = ChangeSetBuilder.creator("TestChangeSet") .with(ChangeSetBuilder::changes, Collections.singletonList(changeBuilder.build())).build(); assertNotNull(changeSet); assertThat(changeSet.getChanges().size(), is(1)); final Change generatedChange = changeSet.getChanges().iterator().next(); assertNotNull(generatedChange); assertThat(generatedChange.getRuleChanges().size(), is(3)); final List<RuleChange> originalRuleChanges = generatedChange.getRuleChanges().stream().filter(ruleChange -> Type.ORIGINAL.equals(ruleChange.getType())).collect(Collectors.toList()); assertThat(originalRuleChanges.size(), is(1)); final List<RuleChange> newRuleChanges = generatedChange.getRuleChanges().stream().filter(ruleChange -> Type.NEW.equals(ruleChange.getType())).collect(Collectors.toList()); assertThat(newRuleChanges.size(), is(2)); } @Test public void createValueGroupChangeToCommissionsCmeGroupFromToday() { final Builder<ChangeBuilder, Change> changeBuilder = ChangeBuilder.creator(this.commissionRuleSet) .with(ChangeBuilder::valueGroupChange, ValueGroupChangeBuilder.creator("CMEGroup") .with(ValueGroupChangeBuilder::ruleSet, this.commissionRuleSet) .with(ValueGroupChangeBuilder::drivers, Arrays.asList("CME, CBOT, NYMEX"))); final ChangeSet changeSet = ChangeSetBuilder.creator("TestChangeSet") .with(ChangeSetBuilder::change, changeBuilder.build()).build(); assertNotNull(changeSet); assertThat(changeSet.getChanges().size(), is(1)); final Change generatedChange = changeSet.getChanges().iterator().next(); assertNotNull(generatedChange); }
RollbackChangeBuilder { public static Builder<RollbackChangeBuilder, Change> creator() { return Builder.instanceOf(RollbackChangeBuilder.create(), RollbackChangeBuilder.validate(), RollbackChangeBuilder::builds); } static Builder<RollbackChangeBuilder, Change> creator(); RollbackChangeBuilder change(final Change change); RollbackChangeBuilder date(final Instant activationTime); RollbackChangeBuilder audit(final Audit audit); }
@Test public void noChangeInformation() { final Builder<RollbackChangeBuilder, Change> builder = RollbackChangeBuilder.creator(); assertNull(builder.build()); }
ValueGroupChangeBuilder extends DomainBuilder<ValueGroupChange, ValueGroup> { public static Builder<ValueGroupChangeBuilder, List<ValueGroupChange>> creator(final String valueGroupName) { return Builder.instanceOf(ValueGroupChangeBuilder.create(valueGroupName), ValueGroupChangeBuilder::builds); } private ValueGroupChangeBuilder(final String valueGroupName); static Builder<ValueGroupChangeBuilder, List<ValueGroupChange>> creator(final String valueGroupName); ValueGroupChangeBuilder ruleSet(final DecisionTreeRuleSet ruleSet); ValueGroupChangeBuilder drivers(final List<String> drivers); void changeRange(final DateRange range); ValueGroupChangeBuilder id(final UUID id); ValueGroupChangeBuilder driver(final String driverName); ValueGroupChangeBuilder ruleCodes(final List<UUID> ruleCodes); ValueGroupChangeBuilder changeType(final Type type); }
@Test(expected = IllegalArgumentException.class) public void nullNameProvided() { builder = ValueGroupChangeBuilder.creator(null); builder.build(); } @Test(expected = IllegalArgumentException.class) public void blankNameProvided() { builder = ValueGroupChangeBuilder.creator(" "); builder.build(); } @Test(expected = IllegalStateException.class) public void noRuleSet() { builder = ValueGroupChangeBuilder.creator("TestValueGroup"); builder.build(); } @Test public void createsBrandNewValueGroup() { builder = ValueGroupChangeBuilder.creator("BrandNewTestValueGroup"); builder.with(ValueGroupChangeBuilder::ruleSet, ruleSet); builder.with(ValueGroupChangeBuilder::drivers, Arrays.asList("Test1", "Test2", "Test4")); builder.with(ValueGroupChangeBuilder::changeRange, new DateRange(NOW, NOW.plus(Period.ofWeeks(1)))); final List<ValueGroupChange> changes = builder.build(); assertThat(changes, hasSize(1)); assertValueGroupChange(changes.get(0), Type.NEW, null, "BrandNewTestValueGroup", NOW, NOW.plus(Period.ofWeeks(1)), Arrays.asList("Test1", "Test2", "Test4")); }
ValueGroupChangeBuilder extends DomainBuilder<ValueGroupChange, ValueGroup> { private ValueGroup getValueGroup(final ValueGroupChangeBuilder builder, final UUID id, final String name, final List<String> values, final DateRange range) { final ValueGroup group = new ValueGroup(id, name, values, range); if (builder.driverName != null) { group.setNewRuleData(builder.driverName, builder.ruleCodes); } return group; } private ValueGroupChangeBuilder(final String valueGroupName); static Builder<ValueGroupChangeBuilder, List<ValueGroupChange>> creator(final String valueGroupName); ValueGroupChangeBuilder ruleSet(final DecisionTreeRuleSet ruleSet); ValueGroupChangeBuilder drivers(final List<String> drivers); void changeRange(final DateRange range); ValueGroupChangeBuilder id(final UUID id); ValueGroupChangeBuilder driver(final String driverName); ValueGroupChangeBuilder ruleCodes(final List<UUID> ruleCodes); ValueGroupChangeBuilder changeType(final Type type); }
@Test public void createsNewChange() { builder.with(ValueGroupChangeBuilder::drivers, Arrays.asList("Test1", "Test2", "Test4")); builder.with(ValueGroupChangeBuilder::changeRange, new DateRange(NOW, NOW.plus(Period.ofWeeks(1)))); builder.with(ValueGroupChangeBuilder::driver, "TestDriver"); final UUID id = UUID.randomUUID(); builder.with(ValueGroupChangeBuilder::ruleCodes, Collections.singletonList(id)); final List<ValueGroupChange> changes = builder.build(); assertThat(changes, hasSize(1)); final ValueGroupChange change = changes.get(0); assertValueGroupChange(change, Type.NEW, null, "TestValueGroup", NOW, NOW.plus(Period.ofWeeks(1)), Arrays.asList("Test1", "Test2", "Test4")); assertEquals("TestDriver", change.getValueGroup().getDriverName()); assertThat(change.getValueGroup().getRuleCodes(), contains(id)); } @Test public void createsValueGroupChangesForExistingValueGroups() { final UUID code = UUID.randomUUID(); builder.with(ValueGroupChangeBuilder::changeType, Type.NONE); builder.with(ValueGroupChangeBuilder::driver, "TestDriver"); builder.with(ValueGroupChangeBuilder::ruleCodes, Arrays.asList(code)); final List<ValueGroupChange> changes = builder.build(); assertThat(changes, hasSize(1)); final ValueGroupChange groupChange = changes.get(0); assertEquals(Type.NONE, groupChange.getType()); final ValueGroup created = groupChange.getValueGroup(); final ValueGroup original = valueGroups.stream().findFirst().get(); assertEquals(original.getId(), created.getId()); assertEquals(original.getName(), created.getName()); assertEquals(original.getRange(), created.getRange()); assertThat(created.getValues(), hasItems("Test1", "Test2", "Test3")); assertNull(original.getDriverName()); assertEquals("TestDriver", created.getDriverName()); assertTrue(original.getRuleCodes().isEmpty()); assertThat(created.getRuleCodes(), hasItem(code)); }
Audit { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } final Audit audit = (Audit) other; return Objects.equals(this.initiator, audit.getInitiator()) && Objects.equals(this.initiatorTime, audit.getInitiatorTime()) && Objects.equals(this.authoriser, audit.getAuthoriser()) && Objects.equals(this.authoriserTime, audit.getAuthoriserTime()); } Audit(final String initiator, final Instant initiatorTime, final String authoriser, final Instant authoriserTime); String getInitiator(); Instant getInitiatorTime(); String getAuthoriser(); Instant getAuthoriserTime(); @Override boolean equals(final Object other); @Override int hashCode(); }
@Test public void equalsCorrect() { final Instant now = Instant.now(); final Audit audit = new Audit("USER1", now, "USER2", now); assertTrue(audit.equals(audit)); assertFalse(audit.equals(null)); assertFalse(audit.equals(Boolean.TRUE)); Audit other = new Audit("USER1", now, "USER2", now); assertTrue(audit.equals(other)); other = new Audit(null, now, "USER2", now); assertFalse(audit.equals(other)); other = new Audit(null, null, "USER2", now); assertFalse(audit.equals(other)); other = new Audit(null, null, null, now); assertFalse(audit.equals(other)); other = new Audit(null, null, null, null); assertFalse(audit.equals(other)); }
Audit { @Override public int hashCode() { return Objects.hashCode(this.initiator) + Objects.hashCode(this.initiatorTime) + Objects.hashCode(this.authoriser) + Objects.hashCode(this.authoriserTime); } Audit(final String initiator, final Instant initiatorTime, final String authoriser, final Instant authoriserTime); String getInitiator(); Instant getInitiatorTime(); String getAuthoriser(); Instant getAuthoriserTime(); @Override boolean equals(final Object other); @Override int hashCode(); }
@Test public void hashCodeCorrect() { final Instant now = Instant.now(); final Audit audit = new Audit("USER1", now, "USER2", now); final Audit other = new Audit("USER1", now, "USER2", now); assertEquals(audit.hashCode(), other.hashCode()); }
ChangeApplier { public static void apply(final DecisionTreeRuleSet ruleSet, final Change change) { ruleSet.updateRules(change); } private ChangeApplier(); static void apply(final DecisionTreeRuleSet ruleSet, final Change change); }
@Test public void testAppliesChangeToRuleSet() { final DecisionTreeRuleSet ruleSet = mock(DecisionTreeRuleSet.class); final Change change = mock(Change.class); ChangeApplier.apply(ruleSet, change); verify(ruleSet).updateRules(change); }
ChangeableDecisionTree extends DecisionTree { public static ChangeableDecisionTree instanceOf(final Loader<DecisionTreeRuleSet> loader, final DecisionTreeType type, final Persister persister) { final ActionRetrier<DecisionTreeRuleSet> retrier = Retrier.createNonRetrier(); final Result<DecisionTreeRuleSet> result = retrier.run(loader, booleanResult -> false); EhSupport.checkResult(result); return new ChangeableDecisionTree(loader, type, result.getData(), persister); } private ChangeableDecisionTree(final Loader<DecisionTreeRuleSet> loader, final DecisionTreeType type, final DecisionTreeRuleSet decisionTreeRuleSet, final Persister persister); static ChangeableDecisionTree instanceOf(final Loader<DecisionTreeRuleSet> loader, final DecisionTreeType type, final Persister persister); Builder<ChangeBuilder, Change> createChange(final String user, final DateRange range); Change applyChange(final Builder<ChangeBuilder, Change> builder, final String approver); }
@Test public void testDecisionTreeEvaluation() { final DecisionTree decisionTree = ChangeableDecisionTree.instanceOf(new CommisionRuleSetSupplier(), DecisionTreeType.SINGLE); assertNotNull(decisionTree); final Input input = decisionTree.createInputs("VOICE", "CME", "ED", "US", "RATE"); final Optional<OutputResults> results = decisionTree.getSingleEvaluationFor(input); assertTrue(results.isPresent()); assertEquals("1.4", results.get().results().get("Rate")); }
Evaluator { public static Optional<UUID> singleEvaluate(final List<String> searchInputs, final Instant time, final TreeNode rootNode) { final List<UUID> results = evaluate(searchInputs, time, Collections.emptyList(), rootNode); if (results.isEmpty()) { return Optional.empty(); } return Optional.of(results.get(0)); } private Evaluator(); static Optional<UUID> singleEvaluate(final List<String> searchInputs, final Instant time, final TreeNode rootNode); static List<UUID> evaluate(final List<String> searchInputs, final Instant time, final List<String> evaluationInputs, final TreeNode rootNode); static List<EvaluationResult> evaluateAllResults(final List<String> searchInputs, final Instant time, final TreeNode rootNode); static List<EvaluationResult> evaluateAllResultsWithWildcards(final List<String> searchInputs, final Instant time, final TreeNode rootNode); }
@Test public void testSimpleEvaluatorWithAllInputs() { final DecisionTreeRuleSet ruleSet = CommisionRuleSetSupplier.getCommisionRuleSet().build(); final TreeNode node = constructTree(ruleSet); Optional<UUID> result = Evaluator.singleEvaluate(Arrays.asList("VOICE", "CME", "ED", "US", "RATE"), null, node); assertTrue(result.isPresent()); assertEquals(new UUID(0, 2), result.get()); result = Evaluator.singleEvaluate(Arrays.asList("VOICE", "CME", "EB", "US", "RATE"), null, node); assertTrue(result.isPresent()); assertEquals(new UUID(0, 3), result.get()); result = Evaluator.singleEvaluate(Arrays.asList("VOICE", "CME", "S&P", "US", "INDEX"), null, node); assertTrue(result.isPresent()); assertEquals(new UUID(0, 3), result.get()); result = Evaluator.singleEvaluate(Arrays.asList("ELECTRONIC", "CME", "S&P", "US", "INDEX"), null, node); assertTrue(result.isPresent()); assertEquals(new UUID(0, 1), result.get()); result = Evaluator.singleEvaluate(Arrays.asList("ELECTRONIC", "LIFFE", "L", "UK", "INDEX"), null, node); assertTrue(result.isPresent()); assertEquals(new UUID(0, 5), result.get()); result = Evaluator.singleEvaluate(Arrays.asList("ELECTRONIC", "CME", "EB", "US", "RATE"), null, node); assertTrue(result.isPresent()); assertEquals(new UUID(0, 4), result.get()); result = Evaluator.singleEvaluate(Arrays.asList("VOICE", "LIFFE", "L", "UK", "INDEX"), null, node); assertTrue(result.isPresent()); assertEquals(new UUID(0, 5), result.get()); result = Evaluator.singleEvaluate(Arrays.asList("VOICE", "CME", "ED", "UK", "INDEX"), null, node); assertTrue(result.isPresent()); assertEquals(new UUID(0, 0), result.get()); result = Evaluator.singleEvaluate(Arrays.asList("VOICE", "CME", "ED", "UK", "BOND"), null, node); assertTrue(result.isPresent()); assertEquals(new UUID(0, 5), result.get()); result = Evaluator.singleEvaluate(Arrays.asList("ELECTRONIC", "EURONEXT", "DEX", "EU", "BOND"), null, node); assertFalse(result.isPresent()); result = Evaluator.singleEvaluate(Arrays.asList("VOICE", "CME", "ED", "EU", "BOND"), null, node); assertFalse(result.isPresent()); } @Test public void testEvaluatorWithRegexInput() { final DecisionTreeRuleSet ruleSet = CommisionRuleSetSupplier.getCommissionRuleSetWithRegex().build(); final TreeNode node = constructTree(ruleSet); final Optional<UUID> result = Evaluator.singleEvaluate(Arrays.asList("VOICE", "CME", "NDK", "APAC", "INDEX"), null, node); assertTrue(result.isPresent()); assertEquals(new UUID(0, 6), result.get()); } @Test public void testEvaluatorWithAlternativePathsAndValueGroups() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> ruleSetBuilder = RuleSetBuilder.creator(Arrays.asList("MARKUP_CODE", "CLIENT_ACCOUNT", "CLIENT_SPN", "ADVISOR_SPN", "EXECUTION_VENUE", "MEMBERSHIP", "SECURITY_TYPE", "CONTRACT", "FEE_GROUP", "PRODUCT_GROUP", "EXCHANGE", "REGION")); ruleSetBuilder.with(RuleSetBuilder::rule, RuleBuilder.creator() .with(RuleBuilder::input, Arrays.asList("CLM", "*", "VG:AdVG1589CLM:0152035:03227805:0521659", "VG:VG1589CLM:0151488:4679563:7888805", "*", "*", "*", "*", "381", "Equity indices", "VG:IFEU:IFLL", "ER")) .with(RuleBuilder::setId, new UUID(1, 0))); ruleSetBuilder.with(RuleSetBuilder::rule, RuleBuilder.creator() .with(RuleBuilder::input, Arrays.asList("CLM", "*", "VG:AdVG1589CLM:0152035:03227805:0521659", "VG:VG1589CLM:0151488:4679563:7888805", "*", "*", "*", "*", "*", "*", "VG:IFEU:IFLL", "ER")) .with(RuleBuilder::setId, new UUID(2, 0))); ruleSetBuilder.with(RuleSetBuilder::rule, RuleBuilder.creator() .with(RuleBuilder::input, Arrays.asList("CLM", "*", "VG:AdVG1589CLM:0152035:03227805:0521659", "VG:AdVG1589CLM:0151488:3679563:6888805", "*", "*", "*", "*", "*", "*", "VG:IFEU:IFLL", "ER")) .with(RuleBuilder::setId, new UUID(3, 0))); ruleSetBuilder.with(RuleSetBuilder::rule, RuleBuilder.creator() .with(RuleBuilder::input, Arrays.asList("CLM", "*", "VG:AdVG1589CLM:0152035:03227805:0521659", "VG:VG1589CLM:0151488:4679563:7888805", "ELEC", "NMEM", "*", "*", "123", "Equity indices", "VG:IFEU:IFLL", "ER")) .with(RuleBuilder::setId, new UUID(4, 0))); final DecisionTreeRuleSet ruleSet = ruleSetBuilder.build(); final TreeNode node = constructTree(ruleSet); final Optional<UUID> result = Evaluator.singleEvaluate(Arrays.asList("CLM", "A102059551", "0152035", "0151488", "ELEC", "NMEM", "FUTURE", "Y2", "381", "Equity indices", "IFLL", "ER"), null, node); assertTrue(result.isPresent()); assertEquals(new UUID(1, 0), result.get()); }
Evaluator { public static List<EvaluationResult> evaluateAllResultsWithWildcards(final List<String> searchInputs, final Instant time, final TreeNode rootNode) { final List<TreeNode> nextNodes = rootNode.getEvaluatedNodesWithWildcards(searchInputs, time); final List<EvaluationResult> results = new ArrayList<>(1); for (final TreeNode nextNode : nextNodes) { if (nextNode instanceof EvaluationResult) { results.add((EvaluationResult) nextNode); } else { results.addAll(evaluateAllResultsWithWildcards(searchInputs, time, nextNode)); } } return new ArrayList<>(results.stream().distinct().collect( Collectors.toMap(EvaluationResult::getRuleIdentifier, eval -> eval)).values()); } private Evaluator(); static Optional<UUID> singleEvaluate(final List<String> searchInputs, final Instant time, final TreeNode rootNode); static List<UUID> evaluate(final List<String> searchInputs, final Instant time, final List<String> evaluationInputs, final TreeNode rootNode); static List<EvaluationResult> evaluateAllResults(final List<String> searchInputs, final Instant time, final TreeNode rootNode); static List<EvaluationResult> evaluateAllResultsWithWildcards(final List<String> searchInputs, final Instant time, final TreeNode rootNode); }
@Test public void testEvaluatorWithRegexMultipleRulesAndWildcards() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> ruleSetBuilder = CommisionRuleSetSupplier.getCommissionRuleSetWithRegex(); final DecisionTreeRuleSet ruleSet = ruleSetBuilder.build(); final TreeNode node = constructTree(ruleSet); final List<EvaluationResult> results = Evaluator.evaluateAllResultsWithWildcards( Arrays.asList("ELECTRONIC", "CME", "S&P", "US", "INDEX"), null, node); assertNotNull(results); assertEquals(4, results.size()); assertThat(results.stream().map(EvaluationResult::getRuleIdentifier).collect(Collectors.toList()), IsCollectionContaining.hasItems(new UUID(0, 0), new UUID(0, 1), new UUID(0, 4), new UUID(0, 7))); }
StreamLoader implements Loader<DecisionTreeRuleSet>, AutoCloseable { public static StreamLoader jsonLoader(final InputStream json, final RuleBuilderParser parser) { return new StreamLoader(json, parser); } private StreamLoader(final InputStream stream, final RuleBuilderParser parser); static StreamLoader jsonLoader(final InputStream json, final RuleBuilderParser parser); static StreamLoader csvLoader(final String name, final InputStream csvInput); @Override boolean test(final Result result); @Override Result<DecisionTreeRuleSet> get(); @Override void close(); }
@Test public void nullInputStream() { String message = null; try { StreamLoader.jsonLoader(null, parser); } catch (final Exception exception) { message = exception.getMessage(); } assertEquals("ruleset input stream is null.", message); }