Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: 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(); }### Answer: @Test public void T_getBinarySize_1(){ FloatRangeBlockIndex bIndex = new FloatRangeBlockIndex( (float)10 , (float)20 ); assertEquals( Float.BYTES * 2 , bIndex.getBinarySize() ); }
### Question: 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 ); }### Answer: @Test public void T_getBinarySize_1() throws IOException{ BlockIndexNode b = new BlockIndexNode(); assertEquals( 8 , b.getBinarySize() ); }
### Question: 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(); }### Answer: @Test public void T_getBlockIndexType_1(){ IBlockIndex bIndex = new StringRangeBlockIndex(); assertEquals( BlockIndexType.RANGE_STRING , bIndex.getBlockIndexType() ); }
### Question: 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(); }### Answer: @Test public void T_getBinarySize_1(){ StringRangeBlockIndex bIndex = new StringRangeBlockIndex( "10" , "20" ); assertEquals( Integer.BYTES * 2 + Character.BYTES * 4 , bIndex.getBinarySize() ); }
### Question: 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(); }### Answer: @Test public void T_getBlockIndexType_1(){ IBlockIndex bIndex = new ByteRangeBlockIndex(); assertEquals( BlockIndexType.RANGE_BYTE , bIndex.getBlockIndexType() ); }
### Question: 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(); }### Answer: @Test public void T_getBinarySize_1(){ ByteRangeBlockIndex bIndex = new ByteRangeBlockIndex( (byte)10 , (byte)20 ); assertEquals( 2 , bIndex.getBinarySize() ); }
### Question: 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; }### Answer: @Test public void T_getBlockIndexType_1(){ assertEquals( BlockIndexType.UNSUPPORTED , UnsupportedBlockIndex.INSTANCE.getBlockIndexType() ); }
### Question: 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; }### Answer: @Test public void T_merge_1(){ assertFalse( UnsupportedBlockIndex.INSTANCE.merge( null ) ); }
### Question: 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; }### Answer: @Test public void T_getBinarySize_1(){ assertEquals( 0 , UnsupportedBlockIndex.INSTANCE.getBinarySize() ); }
### Question: 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; }### Answer: @Test public void T_binary_1(){ byte[] binary = UnsupportedBlockIndex.INSTANCE.toBinary(); assertEquals( 0 , binary.length ); }
### Question: 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; }### Answer: @Test public void T_write_1() throws IOException{ ParserWritable writable = new ParserWritable(); assertThrows( UnsupportedOperationException.class , () -> { writable.write( null ); } ); }
### Question: 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; }### Answer: @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_); } }
### Question: 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; }### Answer: @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_); } }
### Question: 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; }### Answer: @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_); } }
### Question: 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; }### Answer: @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 ()); } }
### Question: 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); }### Answer: @Test public void testClear() { addAllRectangles(); assertTrue(tree.getDrawingObjects().size() == 4); tree.clear(); assertTrue(tree.getDrawingObjects().isEmpty()); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @Test public void addTest(){ JSONArray array = JSONUtil.createArray(); array.add("value1"); array.add("value2"); array.add("value3"); Assert.assertEquals(array.get(0), "value1"); }
### Question: 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); }### Answer: @Test public void parseTest(){ String jsonStr = "[\"value1\", \"value2\", \"value3\"]"; JSONArray array = JSONUtil.parseArray(jsonStr); Assert.assertEquals(array.get(0), "value1"); }
### Question: 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); }### Answer: @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"); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @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()); }
### Question: 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(); }### Answer: @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(); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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))); }
### Question: 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; }### Answer: @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))); }
### Question: 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; }### Answer: @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))); }
### Question: 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; }### Answer: @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]); }
### Question: 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(); }### Answer: @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()); }
### Question: 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(); }### Answer: @Test(expected = IllegalArgumentException.class) public void testTooManyDriversToWeightedDrivers() { final List<String> driverNames = IntStream.range(1, 33).mapToObj(String::valueOf).collect(Collectors.toList()); DecisionTreeRuleSet.convertNamesToWeightedDrivers(driverNames); }
### Question: 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(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testingImmutableValueGroups() { final DecisionTreeRuleSet commisssionRuleSet = CommisionRuleSetSupplier.getCommissionRuleSetWithRegex().build(); commisssionRuleSet.getValueGroups().clear(); }
### Question: 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(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testingImmutableDrivers() { final DecisionTreeRuleSet commisssionRuleSet = CommisionRuleSetSupplier.getCommissionRuleSetWithRegex().build(); commisssionRuleSet.getDriverNames().clear(); }
### Question: 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(); }### Answer: @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)); }
### Question: 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(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testingImmutableEvaluationNames() { final DecisionTreeRuleSet commisssionRuleSet = CommisionRuleSetSupplier.getCommissionRuleSetWithRegex().build(); commisssionRuleSet.getEvaluationNames().clear(); }
### Question: 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(); }### Answer: @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}$"))); }
### Question: 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; }### Answer: @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)); }
### Question: 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; }### Answer: @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()); }
### Question: 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; }### Answer: @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()); }
### Question: 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(); }### Answer: @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)); }
### Question: 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); }### Answer: @Test public void testRegExInput() { assertThat(InputBuilder.regExInput(".RegEx"), is("RE:.RegEx")); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @Test public void testIntegerRangeInput() { assertThat(InputBuilder.integerRangeInput(new Range<>(100, 500)), is("IR:100\|500")); }
### Question: 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(); }### Answer: @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); }
### Question: 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); }### Answer: @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")); }
### Question: 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(); }### Answer: @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)); }
### Question: 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); }### Answer: @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); }
### Question: 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(); }### Answer: @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()); }
### Question: 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(); }### Answer: @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)); }
### Question: 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(); }### Answer: @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()); }
### Question: 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(); }### Answer: @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)); }
### Question: 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(); }### Answer: @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()); }
### Question: 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); }### Answer: @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())); } }); }
### Question: 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); }### Answer: @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(); }
### Question: 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); }### Answer: @Test public void noChangeInformation() { final Builder<RollbackChangeBuilder, Change> builder = RollbackChangeBuilder.creator(); assertNull(builder.build()); }
### Question: 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); }### Answer: @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")); }
### Question: 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); }### Answer: @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)); }
### Question: 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(); }### Answer: @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)); }
### Question: 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(); }### Answer: @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()); }
### Question: 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); }### Answer: @Test public void testAppliesChangeToRuleSet() { final DecisionTreeRuleSet ruleSet = mock(DecisionTreeRuleSet.class); final Change change = mock(Change.class); ChangeApplier.apply(ruleSet, change); verify(ruleSet).updateRules(change); }
### Question: 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); }### Answer: @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")); }
### Question: 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); }### Answer: @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))); }
### Question: 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(); }### Answer: @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); }
### Question: ChangeSet { public boolean addChange(final Change change) { EhSupport.ensureArg(change != null, "Cannot add a null change"); return this.changes.add(change); } ChangeSet(final UUID id, final String name, final Set<Change> changes); UUID getId(); String getName(); Set<Change> getChanges(); boolean addChange(final Change change); boolean removeChange(final Change change); }### Answer: @Test public void addChange() { testConstruction(); final Set<RuleChange> ruleChanges = new HashSet<>(1); final Instant start = NOW.minus(Period.ofWeeks(-1)); final Instant end = start.plus(Period.ofWeeks(5)); final DateRange range = new DateRange(start, end); final InputDriver[] drivers = getInputDriverArray("Test1", "Test2", "Test3"); final Map<String, String> outputs = Collections.singletonMap("outputDriver", "result"); final DecisionTreeRule rule = new DecisionTreeRule(new UUID(0, 7), new UUID(0, 7), drivers, outputs, start, end); final RuleChange ruleChange = new RuleChange(Type.ORIGINAL, rule); ruleChanges.add(ruleChange); final Set<ValueGroupChange> valueGroupChanges = new HashSet<>(); final List<String> valueGroupDrivers = getValueGroupsDrivers("Test1", "Test2", "Test3"); final ValueGroup valueGroup = new ValueGroup(new UUID(0, 8), "TestValueGroup", valueGroupDrivers, range); final ValueGroupChange valueGroupChange = new ValueGroupChange(Type.NEW, valueGroup); valueGroupChanges.add(valueGroupChange); 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(ADDED_CHANGE_ID, "TEST-RULESET", NOW, CHANGE_RANGE, audit, ruleChanges, valueGroupChanges); getBean().addChange(change); assertThat(getBean().getChanges(), hasSize(2)); assertThat(getBean().getChanges(), hasItem(change)); } @Test(expected = IllegalArgumentException.class) public void cannotAddNullChange() { testConstruction(); getBean().addChange(null); }
### Question: OutputResults { public Map<String, String> results() { return this.rule.getOutputs(); } OutputResults(final DecisionTreeRule rule); Map<String, String> results(); }### Answer: @Test public void testConstruction() { final Map<String, String> outputDriver = Collections.singletonMap("outputDriver", "result"); final DecisionTreeRule decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), null, outputDriver, Instant.now(), Instant.now()); final OutputResults results = new OutputResults(decisionTreeRule); Assert.assertEquals(outputDriver, results.results()); }
### Question: GroupEvaluation implements Predicate<String> { @Override public boolean test(final String input) { if (this.group.contains(input)) { return true; } for (final InputDriver driver : this.drivers) { if (driver.evaluate(input)) { return true; } } return false; } GroupEvaluation(final String value, final List<InputDriver> inputDrivers); void setSubValues(final List<InputDriver> inputDrivers); @Override boolean test(final String input); @Override boolean equals(final Object other); @Override int hashCode(); }### Answer: @Test public void testEvaluation() { final GroupEvaluation groupEvaluation = new GroupEvaluation("TestGroup", GroupDriverTest.createSubInputDrivers("test")); assertTrue(groupEvaluation.test("test1")); assertTrue(groupEvaluation.test("test2")); assertTrue(groupEvaluation.test("test3")); assertTrue(groupEvaluation.test("test4")); assertFalse(groupEvaluation.test("test5")); assertFalse(groupEvaluation.test("TestGroup")); }
### Question: GroupEvaluation implements Predicate<String> { @Override public int hashCode() { return this.value.hashCode(); } GroupEvaluation(final String value, final List<InputDriver> inputDrivers); void setSubValues(final List<InputDriver> inputDrivers); @Override boolean test(final String input); @Override boolean equals(final Object other); @Override int hashCode(); }### Answer: @Test public void hashCodeValue() { final GroupEvaluation driver = new GroupEvaluation("Test1", Arrays.asList(new StringDriver("test"))); final GroupEvaluation other = new GroupEvaluation("Test1", Arrays.asList(new StringDriver("test"))); assertTrue(driver.hashCode() == other.hashCode()); }
### Question: GroupEvaluation implements Predicate<String> { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null \|\| getClass() != other.getClass()) { return false; } return this.value.equals(((GroupEvaluation) other).value); } GroupEvaluation(final String value, final List<InputDriver> inputDrivers); void setSubValues(final List<InputDriver> inputDrivers); @Override boolean test(final String input); @Override boolean equals(final Object other); @Override int hashCode(); }### Answer: @Test public void equalsCorrect() { final GroupEvaluation driver = new GroupEvaluation("Test1", Arrays.asList(new StringDriver("test"))); assertTrue(driver.equals(driver)); assertFalse(driver.equals(null)); assertFalse(driver.equals(Boolean.TRUE)); GroupEvaluation other = new GroupEvaluation("Test1", Arrays.asList(new StringDriver("test"))); assertTrue(driver.equals(other)); other = new GroupEvaluation("Test10", Arrays.asList(new StringDriver("test"))); assertFalse(driver.equals(other)); }
### Question: TimeSlicedRootNode implements TreeNode { Optional<DecisionTreeRuleSet> getSlicedRuleSet(final Instant time) { final Map<UUID, DecisionTreeRule> ruleMap = new HashMap<>(); final Optional<Range<Instant>> activeRange = getActiveRange(time); if (activeRange.isPresent()) { ruleSet.getRules().forEach((ruleId, rule) -> { if (PREDICATE_RULE_START_CHECK.test(activeRange.get().getStart(), rule.getStart()) && PREDICATE_RULE_END_CHECK.test(activeRange.get().getFinish(), rule.getEnd())) { ruleMap.put(ruleId, rule); } }); return Optional.of(new DecisionTreeRuleSet(ruleSet.getName(), ruleMap, ruleSet.getDriverNames(), Collections.emptyList(), ruleSet.getDriverCache(), ruleSet.getValueGroups())); } return Optional.empty(); } TimeSlicedRootNode(final DecisionTreeRuleSet ruleSet); @Override Stream<TreeNode> stream(); @Override boolean evaluate(final String input); @Override List<TreeNode> getEvaluatedNodes(final List<String> inputs, final Instant time); @Override List<TreeNode> getEvaluatedNodesWithWildcards(final List<String> inputs, final Instant time); @Override Optional<TreeNode> getExactNode(final TreeNode inputValue); @Override TreeNode addNode(final TreeNode newNode); @Override InputValueType getDriverType(); @Override String getValue(); @Override InputDriver getDriver(); @Override Range<Instant> getDateRange(); }### Answer: @Test public void testGeneratingSlicedRuleSets() { final DecisionTreeRuleSet ruleSet = CommisionRuleSetSupplier.getSlicedRuleSet().build(); final TimeSlicedRootNode timeSlicedRootNode = (TimeSlicedRootNode) NodeSupplier.createTimeSlicedRootNode(ruleSet).get(); assertNotNull(timeSlicedRootNode); final Optional<DecisionTreeRuleSet> slicedRuleSet = timeSlicedRootNode.getSlicedRuleSet( Instant.parse("2013-03-28T01:00:00Z")); assertTrue(slicedRuleSet.isPresent()); assertNotNull(slicedRuleSet.get().getRules()); assertEquals(Integer.valueOf(2), Integer.valueOf(slicedRuleSet.get().getRules().size())); }
### Question: TimeSlicedRootNode implements TreeNode { @Override public List<TreeNode> getEvaluatedNodes(final List<String> inputs, final Instant time) { EhSupport.ensureArg(time != null, "Time sliced decision tree has %s time", time); final Optional<TreeNode> rootSlicedNode = getTreeNodeForTime(time); EhSupport.ensure(rootSlicedNode.isPresent(), "No slice node found"); return rootSlicedNode.get().getEvaluatedNodes(inputs, time); } TimeSlicedRootNode(final DecisionTreeRuleSet ruleSet); @Override Stream<TreeNode> stream(); @Override boolean evaluate(final String input); @Override List<TreeNode> getEvaluatedNodes(final List<String> inputs, final Instant time); @Override List<TreeNode> getEvaluatedNodesWithWildcards(final List<String> inputs, final Instant time); @Override Optional<TreeNode> getExactNode(final TreeNode inputValue); @Override TreeNode addNode(final TreeNode newNode); @Override InputValueType getDriverType(); @Override String getValue(); @Override InputDriver getDriver(); @Override Range<Instant> getDateRange(); }### Answer: @Test(expected = IllegalArgumentException.class) public void throwsIllegalArgumentException() { final TreeNode node = NodeSupplier.createTimeSlicedRootNode(null).get(); node.getEvaluatedNodes(null, null); }
### Question: ResultNode extends BaseTreeNode implements EvaluationResult, TreeNode { @Override public boolean equals(final Object other) { return false; } ResultNode(final InputDriver driver, final int driverLevel, final DecisionTreeRule rule, final TreeNode delegate); @Override boolean equals(final Object other); @Override int hashCode(); @Override Range<Instant> getDateRange(); @Override UUID getRuleIdentifier(); @Override long getWeight(); @Override Optional<InputDriver[]> getEvaluations(); }### Answer: @Test public void equalsCorrect() { final TreeNode treeNode = NodeSupplier.createResultTreeNode( createGroupDriver("CMEGroup"), NodeSupplier.ROOT_NODE_LEVEL, getRule()).get(); assertFalse(treeNode.equals(treeNode)); }
### Question: ResultNode extends BaseTreeNode implements EvaluationResult, TreeNode { @Override public int hashCode() { return super.hashCode() + Objects.hashCode(this.range); } ResultNode(final InputDriver driver, final int driverLevel, final DecisionTreeRule rule, final TreeNode delegate); @Override boolean equals(final Object other); @Override int hashCode(); @Override Range<Instant> getDateRange(); @Override UUID getRuleIdentifier(); @Override long getWeight(); @Override Optional<InputDriver[]> getEvaluations(); }### Answer: @Test public void hashCodeCorrect() { final TreeNode treeNode = NodeSupplier.createDatedResultTreeNode( createGroupDriver("CMEGroup"), NodeSupplier.ROOT_NODE_LEVEL, getRule()).get(); final TreeNode otherNode = NodeSupplier.createDatedResultTreeNode( createGroupDriver("CMEGroup"), NodeSupplier.ROOT_NODE_LEVEL, getRule()).get(); assertEquals(treeNode.hashCode(), otherNode.hashCode()); } @Test public void hashCodeDatedTreeNodeCorrect() { final TreeNode treeNode = NodeSupplier.createResultTreeNode( createGroupDriver("CMEGroup"), NodeSupplier.ROOT_NODE_LEVEL, getRule()).get(); final TreeNode otherNode = NodeSupplier.createResultTreeNode( createGroupDriver("CMEGroup"), NodeSupplier.ROOT_NODE_LEVEL, getRule()).get(); assertEquals(treeNode.hashCode(), otherNode.hashCode()); }
### Question: DatedTreeNode extends BaseTreeNode { @Override public boolean equals(final Object obj) { if (!(super.equals(obj))) { return false; } final Range<Instant> other = ((BaseTreeNode) obj).getDateRange(); return Objects.equals(this.range, other) \|\| inRange(other.getStart(), this.range) \|\| inRange(other.getFinish(), this.range); } DatedTreeNode(final InputDriver driver, final int level, final Range<Instant> dateRange); @Override boolean equals(final Object obj); @Override int hashCode(); @Override Range<Instant> getDateRange(); @Override void setDateRange(final Range<Instant> range); @Override Optional<TreeNode> getExactNode(final TreeNode inputValue); @Override TreeNode addNode(final TreeNode newNode); @Override List<TreeNode> getEvaluatedNodes(final List<String> inputs, final Instant time); }### Answer: @Test public void equalsCorrect() { final Instant start = NOW.minus(Period.ofWeeks(5)); final Instant end = NOW.plus(Period.ofWeeks(5)); final TreeNode node = createDatedTreeNode("Test1", start, end); TreeNode other = createDatedTreeNode("Test1", start, end); assertTrue(node.equals(other)); other = createDatedTreeNode("Test1", start, Instant.MAX); assertTrue(node.equals(other)); other = createDatedTreeNode("Test1", NOW, Instant.MAX); assertTrue(node.equals(other)); other = createDatedTreeNode("Test1", end, Instant.MAX); assertTrue(node.equals(other)); other = createDatedTreeNode("Test1", Instant.MIN, start); assertTrue(node.equals(other)); other = createDatedTreeNode("Test1", Instant.MIN, NOW); assertTrue(node.equals(other)); other = createDatedTreeNode("Test1", Instant.MIN, end); assertTrue(node.equals(other)); other = createDatedTreeNode("Test1", Instant.MIN, Instant.MAX); assertFalse(node.equals(other)); }
### Question: DatedTreeNode extends BaseTreeNode { @Override public int hashCode() { return super.hashCode() + this.range.hashCode(); } DatedTreeNode(final InputDriver driver, final int level, final Range<Instant> dateRange); @Override boolean equals(final Object obj); @Override int hashCode(); @Override Range<Instant> getDateRange(); @Override void setDateRange(final Range<Instant> range); @Override Optional<TreeNode> getExactNode(final TreeNode inputValue); @Override TreeNode addNode(final TreeNode newNode); @Override List<TreeNode> getEvaluatedNodes(final List<String> inputs, final Instant time); }### Answer: @Test public void hashCodeCorrect() { TreeNode node = createDatedTreeNode("Test1", Instant.MIN, Instant.MAX); assertEquals(node.hashCode(), createDatedTreeNode("Test1", Instant.MIN, Instant.MAX).hashCode()); node = createDatedTreeNode("Test1", null, Instant.MAX); assertEquals(node.hashCode(), createDatedTreeNode("Test1", null, Instant.MAX).hashCode()); node = createDatedTreeNode("Test1", Instant.MIN, null); assertEquals(node.hashCode(), createDatedTreeNode("Test1", Instant.MIN, null).hashCode()); }
### Question: StringEvaluation implements Predicate<String> { @Override public int hashCode() { return this.value.hashCode(); } StringEvaluation(final String value); @Override boolean test(final String input); @Override boolean equals(final Object other); @Override int hashCode(); }### Answer: @Test public void hashCodeValue() { final StringEvaluation driver = new StringEvaluation("Test1"); assertEquals(new StringEvaluation("Test1").hashCode(), driver.hashCode()); }
### Question: StringEvaluation implements Predicate<String> { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null \|\| getClass() != other.getClass()) { return false; } return this.value.equals(((StringEvaluation) other).value); } StringEvaluation(final String value); @Override boolean test(final String input); @Override boolean equals(final Object other); @Override int hashCode(); }### Answer: @Test public void equalsCorrect() { final StringEvaluation driver = new StringEvaluation("Test1"); assertTrue(driver.equals(driver)); assertFalse(driver.equals(null)); assertFalse(driver.equals(new Integer(1))); StringEvaluation other = new StringEvaluation("Test1"); assertTrue(driver.equals(other)); other = new StringEvaluation("Test3"); assertFalse(driver.equals(other)); final RegExEvaluation regExEvaluation = new RegExEvaluation("Test1"); assertFalse(driver.equals(regExEvaluation)); }
### Question: DatedNodeKey { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null \|\| this.getClass() != other.getClass()) { return false; } final DatedNodeKey otherKey = (DatedNodeKey) other; return Objects.equals(getValue(), otherKey.getValue()) && Objects.equals(getRange(), otherKey.getRange()); } DatedNodeKey(final String value, final Range<Instant> range); Range<Instant> getRange(); String getValue(); @Override boolean equals(final Object other); @Override int hashCode(); }### Answer: @Test public void equalsCorrect() { DatedNodeKey key = new DatedNodeKey("test1", new Range<>(DecisionTreeRule.EPOCH, DecisionTreeRule.MAX)); final DatedNodeKey sameKey = new DatedNodeKey("test1", new Range<>(DecisionTreeRule.EPOCH, DecisionTreeRule.MAX)); assertTrue(key.equals(key)); assertTrue(key.equals(sameKey)); assertFalse(key.equals(null)); assertFalse(key.equals(new Integer(1))); DatedNodeKey otherKeyValue = new DatedNodeKey("test2", new Range<>(DecisionTreeRule.EPOCH, DecisionTreeRule.MAX)); assertFalse(key.equals(otherKeyValue)); otherKeyValue = new DatedNodeKey("test1", new Range<>(Instant.now(), DecisionTreeRule.MAX)); assertFalse(key.equals(otherKeyValue)); otherKeyValue = new DatedNodeKey("test1", new Range<>(DecisionTreeRule.EPOCH, Instant.now())); assertFalse(key.equals(otherKeyValue)); otherKeyValue = new DatedNodeKey("test1", new Range<>(DecisionTreeRule.EPOCH, null)); assertFalse(key.equals(otherKeyValue)); otherKeyValue = new DatedNodeKey("test1", new Range<>(null, DecisionTreeRule.MAX)); assertFalse(key.equals(otherKeyValue)); otherKeyValue = new DatedNodeKey("test1", null); assertFalse(key.equals(otherKeyValue)); key = new DatedNodeKey("test1", null); assertTrue(key.equals(otherKeyValue)); otherKeyValue = new DatedNodeKey("test2", new Range<>(DecisionTreeRule.EPOCH, DecisionTreeRule.MAX)); assertFalse(key.equals(otherKeyValue)); }
### Question: DatedNodeKey { @Override public int hashCode() { return getValue().hashCode() + getRange().hashCode(); } DatedNodeKey(final String value, final Range<Instant> range); Range<Instant> getRange(); String getValue(); @Override boolean equals(final Object other); @Override int hashCode(); }### Answer: @Test public void hashCodeCorrect() { final DatedNodeKey key = new DatedNodeKey("test1", new Range<>(DecisionTreeRule.EPOCH, DecisionTreeRule.MAX)); final DatedNodeKey other = new DatedNodeKey("test1", new Range<>(DecisionTreeRule.EPOCH, DecisionTreeRule.MAX)); assertEquals(key.hashCode(), other.hashCode()); }
### Question: GroupDriver extends InputDriver { @Override public int hashCode() { return super.hashCode(); } GroupDriver(final String value, final List<InputDriver> inputDrivers); static void convertDriversIntoDriversAndGroups(final List<InputDriver> originalDrivers, final List<String> drivers, final List<String> groups); InputDriver[] getSubDrivers(final boolean recurse); List<String> convertDrivers(); void setSubValues(final List<InputDriver> subValues); @Override String toString(); @Override boolean equals(final Object other); @Override int hashCode(); static final String VG_PREFIX; }### Answer: @Test public void hashCodeValue() { final InputDriver driver = createInputDriver("Test1", "test"); assertEquals(80698815, driver.hashCode()); }
### Question: GroupDriver extends InputDriver { static List<InputDriver> getSubInputDrivers(final List<InputDriver> originalDrivers, final boolean recurse) { final Set<InputDriver> allDrivers = new HashSet<>(originalDrivers); for (final InputDriver driver : originalDrivers) { if (recurse && InputValueType.VALUE_GROUP.equals(driver.getType())) { getSubInputDrivers(((GroupDriver) driver).originalDrivers, allDrivers); } } return new ArrayList<>(allDrivers); } GroupDriver(final String value, final List<InputDriver> inputDrivers); static void convertDriversIntoDriversAndGroups(final List<InputDriver> originalDrivers, final List<String> drivers, final List<String> groups); InputDriver[] getSubDrivers(final boolean recurse); List<String> convertDrivers(); void setSubValues(final List<InputDriver> subValues); @Override String toString(); @Override boolean equals(final Object other); @Override int hashCode(); static final String VG_PREFIX; }### Answer: @Test public void testOnlyStoreUniqueDrivers() { final List<InputDriver> subDriverList = createSubInputDrivers("test"); final List<InputDriver> duplicateSubDriverList = createSubInputDrivers("test"); final InputDriver dupDriver = new GroupDriver("dup1", duplicateSubDriverList); subDriverList.add(dupDriver); final InputDriver subDriver = new GroupDriver("sub1", subDriverList); final List<InputDriver> drivers = Collections.singletonList(subDriver); final List<InputDriver> inputs = GroupDriver.getSubInputDrivers(drivers, true); assertNotNull(inputs); assertEquals(6, inputs.size()); inputs.forEach(input -> assertThat(1, Matchers.equalTo(Collections.frequency(inputs, input)))); } @Test public void testSameNameOfValueGroupAsStringInGroup() { final List<InputDriver> subDriverList = createSubInputDrivers("test"); subDriverList.add(new StringDriver("test")); final GroupDriver group = new GroupDriver("test", subDriverList); assertNotNull(group); assertTrue(group.evaluate("test")); final List<InputDriver> inputs = GroupDriver.getSubInputDrivers(subDriverList, true); assertNotNull(inputs); }
### Question: GroupDriver extends InputDriver { public InputDriver[] getSubDrivers(final boolean recurse) { final List<InputDriver> allDrivers = getSubInputDrivers(this.originalDrivers, recurse); return allDrivers.toArray(new InputDriver[allDrivers.size()]); } GroupDriver(final String value, final List<InputDriver> inputDrivers); static void convertDriversIntoDriversAndGroups(final List<InputDriver> originalDrivers, final List<String> drivers, final List<String> groups); InputDriver[] getSubDrivers(final boolean recurse); List<String> convertDrivers(); void setSubValues(final List<InputDriver> subValues); @Override String toString(); @Override boolean equals(final Object other); @Override int hashCode(); static final String VG_PREFIX; }### Answer: @Test public void testGetSubDrivers() { final List<InputDriver> subDriverList = createSubInputDrivers("test"); final List<InputDriver> sub2DriverList = createSubInputDrivers("subtest"); final InputDriver sub2Driver = new GroupDriver("sub2", sub2DriverList); subDriverList.add(sub2Driver); final InputDriver subDriver = new GroupDriver("sub1", subDriverList); final List<InputDriver> drivers = Collections.singletonList(subDriver); final GroupDriver group = new GroupDriver("group", drivers); assertNotNull(group); InputDriver[] inputs = group.getSubDrivers(false); assertNotNull(inputs); assertArrayEquals(new InputDriver[]{subDriver}, inputs); inputs = ((GroupDriver) subDriver).getSubDrivers(false); assertNotNull(inputs); assertThat(subDriverList, IsCollectionContaining.hasItems(inputs)); final List<InputDriver> everyDriver = new ArrayList<>(drivers); everyDriver.addAll(sub2DriverList); everyDriver.addAll(subDriverList); inputs = group.getSubDrivers(true); assertNotNull(inputs); assertThat(everyDriver, IsCollectionContaining.hasItems(inputs)); }
### Question: ChangeSet { public boolean removeChange(final Change change) { return this.changes.remove(change); } ChangeSet(final UUID id, final String name, final Set<Change> changes); UUID getId(); String getName(); Set<Change> getChanges(); boolean addChange(final Change change); boolean removeChange(final Change change); }### Answer: @Test public void removeChange() { addChange(); final Audit audit = new Audit("User1", null, "User2", null); Change change = new Change(new UUID(0, 6), "TEST-RULESET", NOW, CHANGE_RANGE, audit, Collections.emptySet(), Collections.emptySet()); getBean().removeChange(change); assertThat(getBean().getChanges(), hasSize(2)); change = new Change(ADDED_CHANGE_ID, "TEST-RULESET", NOW, CHANGE_RANGE, audit, Collections.emptySet(), Collections.emptySet()); getBean().removeChange(change); assertThat(getBean().getChanges(), hasSize(1)); }
### Question: GroupDriver extends InputDriver { @Override public boolean equals(final Object other) { return super.equals(other); } GroupDriver(final String value, final List<InputDriver> inputDrivers); static void convertDriversIntoDriversAndGroups(final List<InputDriver> originalDrivers, final List<String> drivers, final List<String> groups); InputDriver[] getSubDrivers(final boolean recurse); List<String> convertDrivers(); void setSubValues(final List<InputDriver> subValues); @Override String toString(); @Override boolean equals(final Object other); @Override int hashCode(); static final String VG_PREFIX; }### Answer: @Test public void driverEquals() { final InputDriver driver = createInputDriver("Test1", "test"); assertTrue(driver.equals(driver)); assertFalse(driver.equals(null)); assertFalse(driver.equals(new Integer(1))); InputDriver other = createInputDriver("Test1", "test"); assertTrue(driver.equals(other)); other = createInputDriver("Feast", "test"); assertFalse(driver.equals(other)); other = new RegexDriver("Test1"); assertFalse(driver.equals(other)); }
### Question: RegExEvaluation implements Predicate<String> { @Override public boolean test(final String input) { return this.pattern.matcher(input).matches(); } RegExEvaluation(final String value); @Override boolean test(final String input); @Override boolean equals(final Object other); @Override int hashCode(); }### Answer: @Test public void evaluation() { final RegExEvaluation driver = new RegExEvaluation("Te.?t1"); assertTrue(driver.test("Test1")); assertFalse(driver.test("Fest1")); }
### Question: RegExEvaluation implements Predicate<String> { @Override public int hashCode() { return this.pattern.toString().hashCode(); } RegExEvaluation(final String value); @Override boolean test(final String input); @Override boolean equals(final Object other); @Override int hashCode(); }### Answer: @Test public void hashCodeValue() { final RegExEvaluation driver = new RegExEvaluation("Te.?t1"); assertEquals(new RegExEvaluation("Te.?t1").hashCode(), driver.hashCode()); }
### Question: RegExEvaluation implements Predicate<String> { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null \|\| getClass() != other.getClass()) { return false; } return this.pattern.toString().equals(((RegExEvaluation) other).pattern.toString()); } RegExEvaluation(final String value); @Override boolean test(final String input); @Override boolean equals(final Object other); @Override int hashCode(); }### Answer: @Test public void driverEquals() { final RegExEvaluation driver = new RegExEvaluation("Te.?t1"); assertEquals(new RegExEvaluation("Te.?t1"), driver); assertTrue(driver.equals(driver)); assertFalse(driver.equals(null)); assertFalse(driver.equals("Te.?t1")); }
### Question: WeightedDriver implements Comparable<WeightedDriver> { public String getName() { return this.name; } WeightedDriver(final String name, final int weight); String getName(); int getWeight(); @Override int compareTo(final WeightedDriver other); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testOrdering() { final WeightedDriver test1 = new WeightedDriver("TestName1", 1); final WeightedDriver test2 = new WeightedDriver("TestName2", 2); final WeightedDriver test3 = new WeightedDriver("TestName3", 3); final SortedSet<WeightedDriver> weights = new TreeSet<>(); weights.add(test2); weights.add(test1); weights.add(test3); final Iterator<WeightedDriver> iterator = weights.iterator(); assertEquals("TestName3", iterator.next().getName()); assertEquals("TestName2", iterator.next().getName()); assertEquals("TestName1", iterator.next().getName()); }
### Question: DecisionTreeRule implements TreeRule { public boolean isActiveAt(final Instant time) { return time.isAfter(this.start) && time.isBefore(this.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; }### Answer: @Test public void testIsActiveWithinDateRange() { final Instant startInstance = Instant.now().minus(1, ChronoUnit.DAYS); final Instant endInstance = startInstance.plus(2, ChronoUnit.DAYS); final DecisionTreeRule decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, startInstance, endInstance); assertTrue(decisionTreeRule.isActiveAt(Instant.now())); Assert.assertFalse(decisionTreeRule.isActiveAt(Instant.now().minus(2, ChronoUnit.DAYS))); Assert.assertFalse(decisionTreeRule.isActiveAt(Instant.now().plus(2, ChronoUnit.DAYS))); }
### Question: DecisionTreeRule implements TreeRule { public long getRuleWeight() { long weight = 0; long weightedLevel = INITIAL_WEIGHTED_VALUE; for (int i = drivers.length - 1; i >= 0; i--) { if (!InputValueType.WILDCARD.equals(drivers[i].getValue())) { weight += weightedLevel; } weightedLevel = weightedLevel * 2; } return weight; } 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; }### Answer: @Test public void testWeightedCalculations() { DecisionTreeRule decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1"), this.outputDriver, null, null); assertEquals(1, decisionTreeRule.getRuleWeight()); decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null); assertEquals(3, decisionTreeRule.getRuleWeight()); decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", ""), this.outputDriver, null, null); assertEquals(2, decisionTreeRule.getRuleWeight()); decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2", "input3"), this.outputDriver, null, null); assertEquals(7, decisionTreeRule.getRuleWeight()); decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "", "input3"), this.outputDriver, null, null); assertEquals(5, decisionTreeRule.getRuleWeight()); decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("", "", ""), this.outputDriver, null, null); assertEquals(0, decisionTreeRule.getRuleWeight()); decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "", "", ""), this.outputDriver, null, null); assertEquals(8, decisionTreeRule.getRuleWeight()); }
### Question: DecisionTreeRule implements TreeRule { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null \|\| getClass() != other.getClass()) { return false; } final DecisionTreeRule otherRule = (DecisionTreeRule) other; return ruleIdentifier.equals(otherRule.ruleIdentifier); } 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; }### Answer: @Test public void testEquals() { final DecisionTreeRule decisionTreeRule1 = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null); assertFalse(decisionTreeRule1.equals(null)); assertFalse(decisionTreeRule1.equals(new Integer(1))); assertTrue(decisionTreeRule1.equals(decisionTreeRule1)); assertTrue(decisionTreeRule1.equals(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null))); assertTrue(decisionTreeRule1.equals(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input2", "input3"), this.outputDriver, null, null))); assertFalse(decisionTreeRule1.equals(new DecisionTreeRule(new UUID(0, 2), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null))); }
### Question: DecisionTreeRule implements TreeRule { @Override public int hashCode() { return ruleIdentifier.hashCode(); } 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; }### Answer: @Test public void hashCodeCorrect() { final DecisionTreeRule rule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null); final DecisionTreeRule other = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null); assertTrue(rule.hashCode() == other.hashCode()); }
### Question: UserLookUp { public boolean checkUsernameUniqueness( String username, boolean isEncrypted, RequestContext context) { List<Map<String, Object>> userMapList = getRecordByType(JsonKey.USER_LOOKUP_FILED_USER_NAME, username, !isEncrypted, context); if (CollectionUtils.isNotEmpty(userMapList)) { return false; } return true; } Response insertRecords(List<Map<String, Object>> reqMap, RequestContext context); void deleteRecords(List<Map<String, String>> reqMap, RequestContext context); Response insertExternalIdIntoUserLookup( List<Map<String, Object>> reqMap, String userId, RequestContext context); List<Map<String, Object>> getRecordByType( String type, String value, boolean encrypt, RequestContext context); List<Map<String, Object>> getEmailByType(String email, RequestContext context); void checkEmailUniqueness(String email, RequestContext context); void checkEmailUniqueness(User user, String opType, RequestContext context); List<Map<String, Object>> getPhoneByType(String phone, RequestContext context); void checkPhoneUniqueness(String phone, RequestContext context); void checkPhoneUniqueness(User user, String opType, RequestContext context); boolean checkUsernameUniqueness( String username, boolean isEncrypted, RequestContext context); void checkExternalIdUniqueness(User user, String operation, RequestContext context); }### Answer: @Test public void checkUsernameUniqueness() throws Exception { boolean response = new UserLookUp().checkUsernameUniqueness("userName", true, null); assertFalse(response); }
### Question: ElasticSearchRestHighImpl implements ElasticSearchService { @Override public Future<Boolean> delete(String index, String identifier, RequestContext context) { long startTime = System.currentTimeMillis(); logger.info(context, "ElasticSearchRestHighImpl:delete: method started at ==" + startTime); Promise<Boolean> promise = Futures.promise(); if (StringUtils.isNotEmpty(identifier) && StringUtils.isNotEmpty(index)) { DeleteRequest delRequest = new DeleteRequest(index, _DOC, identifier); ActionListener<DeleteResponse> listener = new ActionListener<DeleteResponse>() { @Override public void onResponse(DeleteResponse deleteResponse) { if (deleteResponse.getResult() == DocWriteResponse.Result.NOT_FOUND) { logger.info( context, "ElasticSearchRestHighImpl:delete:OnResponse: Document not found for index : " + index + " , identifier : " + identifier); promise.success(false); } else { promise.success(true); } } @Override public void onFailure(Exception e) { logger.error( context, "ElasticSearchRestHighImpl:delete: Async Failed due to error :", e); promise.failure(e); } }; ConnectionManager.getRestClient().deleteAsync(delRequest, listener); } else { logger.info( context, "ElasticSearchRestHighImpl:delete: " + "provided index or identifier is null, index = " + index + "," + " identifier = " + identifier); promise.failure(ProjectUtil.createClientException(ResponseCode.invalidData)); } logger.info( context, "ElasticSearchRestHighImpl:delete: method end ==" + " ,Total time elapsed = " + calculateEndTime(startTime)); return promise.future(); } @Override Future<String> save( String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Boolean> update( String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Map<String, Object>> getDataByIdentifier( String index, String identifier, RequestContext context); @Override Future<Boolean> delete(String index, String identifier, RequestContext context); @Override @SuppressWarnings({"unchecked", "rawtypes"}) Future<Map<String, Object>> search( SearchDTO searchDTO, String index, RequestContext context); @Override Future<Boolean> healthCheck(); @Override Future<Boolean> bulkInsert( String index, List<Map<String, Object>> dataList, RequestContext context); @Override Future<Boolean> upsert( String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Map<String, Map<String, Object>>> getEsResultByListOfIds( List<String> ids, List<String> fields, String index, RequestContext context); }### Answer: @Test public void testDeleteSuccess() { mockRulesForDelete(false, false); Future<Boolean> result = esService.delete("test", "001", null); boolean res = (boolean) ElasticSearchHelper.getResponseFromFuture(result); assertEquals(true, res); } @Test public void testDeleteSuccessWithoutDelete() { mockRulesForDelete(false, true); Future<Boolean> result = esService.delete("test", "001", null); boolean res = (boolean) ElasticSearchHelper.getResponseFromFuture(result); assertEquals(false, res); } @Test public void testDeleteFailure() { mockRulesForDelete(true, false); Future<Boolean> result = esService.delete("test", "001", null); Object res = ElasticSearchHelper.getResponseFromFuture(result); assertEquals(null, res); } @Test public void testDeleteFailureWithEmptyIdentifier() { try { esService.delete("test", "", null); } catch (ProjectCommonException e) { assertEquals(e.getResponseCode(), ResponseCode.invalidData.getResponseCode()); } } @Test public void testDeleteFailureWithEmptyIndex() { try { esService.delete("", "001", null); } catch (ProjectCommonException e) { assertEquals(e.getResponseCode(), ResponseCode.invalidData.getResponseCode()); } }
### Question: ElasticSearchRestHighImpl implements ElasticSearchService { @Override public Future<Boolean> bulkInsert( String index, List<Map<String, Object>> dataList, RequestContext context) { long startTime = System.currentTimeMillis(); logger.info( context, "ElasticSearchRestHighImpl:bulkInsert: method started at ==" + startTime + " for Index " + index); BulkRequest request = new BulkRequest(); Promise<Boolean> promise = Futures.promise(); for (Map<String, Object> data : dataList) { data.put("identifier", data.get(JsonKey.ID)); request.add(new IndexRequest(index, _DOC, (String) data.get(JsonKey.ID)).source(data)); } ActionListener<BulkResponse> listener = new ActionListener<BulkResponse>() { @Override public void onResponse(BulkResponse bulkResponse) { Iterator<BulkItemResponse> responseItr = bulkResponse.iterator(); if (responseItr != null) { promise.success(true); while (responseItr.hasNext()) { BulkItemResponse bResponse = responseItr.next(); if (bResponse.isFailed()) { logger.info( context, "ElasticSearchRestHighImpl:bulkinsert: api response===" + bResponse.getId() + " " + bResponse.getFailureMessage()); } } } } @Override public void onFailure(Exception e) { logger.error( context, "ElasticSearchRestHighImpl:bulkinsert: Bulk upload error block", e); promise.success(false); } }; ConnectionManager.getRestClient().bulkAsync(request, listener); logger.info( context, "ElasticSearchRestHighImpl:bulkInsert: method end ==" + " for Index " + index + " ,Total time elapsed = " + calculateEndTime(startTime)); return promise.future(); } @Override Future<String> save( String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Boolean> update( String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Map<String, Object>> getDataByIdentifier( String index, String identifier, RequestContext context); @Override Future<Boolean> delete(String index, String identifier, RequestContext context); @Override @SuppressWarnings({"unchecked", "rawtypes"}) Future<Map<String, Object>> search( SearchDTO searchDTO, String index, RequestContext context); @Override Future<Boolean> healthCheck(); @Override Future<Boolean> bulkInsert( String index, List<Map<String, Object>> dataList, RequestContext context); @Override Future<Boolean> upsert( String index, String identifier, Map<String, Object> data, RequestContext context); @Override Future<Map<String, Map<String, Object>>> getEsResultByListOfIds( List<String> ids, List<String> fields, String index, RequestContext context); }### Answer: @Test public void testBuilInsertSuccess() { mockRulesForBulk(false); List<Map<String, Object>> list = new ArrayList<>(); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.IDENTIFIER, "0001"); list.add(map); Future<Boolean> result = esService.bulkInsert("test", list, null); boolean res = (boolean) ElasticSearchHelper.getResponseFromFuture(result); assertEquals(true, res); } @Test public void testBuilInsertFailure() { mockRulesForBulk(true); List<Map<String, Object>> list = new ArrayList<>(); Map<String, Object> map = new HashMap<>(); map.put(JsonKey.IDENTIFIER, "0001"); list.add(map); Future<Boolean> result = esService.bulkInsert("test", list, null); boolean res = (boolean) ElasticSearchHelper.getResponseFromFuture(result); assertEquals(false, res); }
### Question: MigrationUtils { public static ShadowUser getRecordByUserId(String userId, RequestContext context) { ShadowUser shadowUser = null; Response response = cassandraOperation.searchValueInList( JsonKey.SUNBIRD, JsonKey.SHADOW_USER, JsonKey.USERIDS, userId, context); if (!((List) response.getResult().get(JsonKey.RESPONSE)).isEmpty()) { shadowUser = mapper.convertValue( ((List) response.getResult().get(JsonKey.RESPONSE)).get(0), ShadowUser.class); } return shadowUser; } static ShadowUser getRecordByUserId(String userId, RequestContext context); static boolean updateRecord( Map<String, Object> propertiesMap, String channel, String userExtId, RequestContext context); static boolean markUserAsRejected(ShadowUser shadowUser, RequestContext context); static boolean updateClaimStatus( ShadowUser shadowUser, int claimStatus, RequestContext context); static List<ShadowUser> getEligibleUsersById( String userId, Map<String, Object> propsMap, RequestContext context); static List<ShadowUser> getEligibleUsersById(String userId, RequestContext context); }### Answer: @Test public void testGetRecordByUserIdSuccess() { ShadowUser shadowUser = MigrationUtils.getRecordByUserId("EFG", null); Assert.assertEquals("TN", shadowUser.getChannel()); } @Test public void testGetRecordByUserIdFailure() { ShadowUser shadowUser = MigrationUtils.getRecordByUserId("DEF", null); Assert.assertEquals(null, shadowUser); }
### Question: ElasticSearchMapping { public static String createMapping() { String mapping = " { \"dynamic_templates\": [ {\"longs\": {\"match_mapping_type\": \"long\", \"mapping\": {\"type\": \"long\", \"fields\": { \"raw\": {\"type\": \"long\" } }}}},{\"booleans\": {\"match_mapping_type\": \"boolean\", \"mapping\": {\"type\": \"boolean\", \"fields\": { \"raw\": { \"type\": \"boolean\" }} }}},{\"doubles\": {\"match_mapping_type\": \"double\",\"mapping\": {\"type\": \"double\",\"fields\":{\"raw\": { \"type\": \"double\" } }}}},{ \"dates\": {\"match_mapping_type\": \"date\", \"mapping\": { \"type\": \"date\",\"fields\": {\"raw\": { \"type\": \"date\" } } }}},{\"strings\": {\"match_mapping_type\": \"string\",\"mapping\": {\"type\": \"text\",\"fielddata\": true,\"copy_to\": \"all_fields\",\"analyzer\": \"cs_index_analyzer\",\"search_analyzer\": \"cs_search_analyzer\",\"fields\": {\"raw\": {\"type\": \"text\",\"fielddata\": true,\"analyzer\": \"keylower\"}}}}}],\"properties\": {\"all_fields\": {\"type\": \"text\",\"analyzer\": \"cs_index_analyzer\",\"search_analyzer\": \"cs_search_analyzer\",\"fields\": { \"raw\": { \"type\": \"text\",\"analyzer\": \"keylower\" } }} }}"; return mapping; } static String createMapping(); }### Answer: @Test public void testcreateMapping() { String mapping = ElasticSearchMapping.createMapping(); Assert.assertNotNull(mapping); }
### Question: ElasticSearchSettings { public static String createSettingsForIndex() { String settings = "{\"analysis\": {\"analyzer\": {\"cs_index_analyzer\": {\"type\": \"custom\",\"tokenizer\": \"standard\",\"filter\": [\"lowercase\",\"mynGram\"]},\"cs_search_analyzer\": {\"type\": \"custom\",\"tokenizer\": \"standard\",\"filter\": [\"lowercase\",\"standard\"]},\"keylower\": {\"type\": \"custom\",\"tokenizer\": \"keyword\",\"filter\": \"lowercase\"}},\"filter\": {\"mynGram\": {\"type\": \"ngram\",\"min_gram\": 1,\"max_gram\": 20,\"token_chars\": [\"letter\", \"digit\",\"whitespace\",\"punctuation\",\"symbol\"]} }}}"; return settings; } static String createSettingsForIndex(); }### Answer: @Test public void testcreateSettingsForIndex() { String settings = ElasticSearchSettings.createSettingsForIndex(); Assert.assertNotNull(settings); }
### Question: TelemetryGenerator { public static String audit(Map<String, Object> context, Map<String, Object> params) { if (!validateRequest(context, params)) { return ""; } String actorId = (String) context.get(JsonKey.ACTOR_ID); String actorType = (String) context.get(JsonKey.ACTOR_TYPE); Actor actor = new Actor(actorId, StringUtils.capitalize(actorType)); Target targetObject = generateTargetObject((Map<String, Object>) params.get(JsonKey.TARGET_OBJECT)); Context eventContext = getContext(context); if (params.containsKey(JsonKey.CORRELATED_OBJECTS)) { setCorrelatedDataToContext(params.get(JsonKey.CORRELATED_OBJECTS), eventContext); } String reqId = (String) context.get(JsonKey.X_REQUEST_ID); if (!StringUtils.isBlank(reqId)) { Map<String, Object> map = new HashMap<>(); map.put(JsonKey.ID, reqId); map.put(JsonKey.TYPE, TelemetryEnvKey.REQUEST_UPPER_CAMEL); eventContext.getCdata().add(map); } Map<String, Object> edata = generateAuditEdata(params); Telemetry telemetry = new Telemetry(TelemetryEvents.AUDIT.getName(), actor, eventContext, edata, targetObject); telemetry.setMid(reqId); return getTelemetry(telemetry); } private TelemetryGenerator(); static String audit(Map<String, Object> context, Map<String, Object> params); static String search(Map<String, Object> context, Map<String, Object> params); static String log(Map<String, Object> context, Map<String, Object> params); static String error(Map<String, Object> context, Map<String, Object> params); }### Answer: @Test public void testAudit() { String audit = TelemetryGenerator.audit(context, params); assertNotNull(audit); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.