Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: MDSStructObjectInspector extends SettableStructObjectInspector { @Override public List<Object> getStructFieldsDataAsList( final Object object ){ ColumnAndIndex columnAndIndex = (ColumnAndIndex) object; List<Object> result = new ArrayList<Object>( fields.size() ); for( StructField field : fields ){ MDSStructField structFiled = (MDSStructField)field; result.add( structFiled.getValue( (ColumnAndIndex)object ) ); } return result; } MDSStructObjectInspector( final StructTypeInfo typeInfo ); @Override List<StructField> getAllStructFieldRefs(); @Override StructField getStructFieldRef( final String s ); @Override Object getStructFieldData( final Object object, final StructField field ); @Override List<Object> getStructFieldsDataAsList( final Object object ); @Override String getTypeName(); @Override Category getCategory(); @Override Object create(); @Override Object setStructFieldData( final Object object, final StructField field , final Object fieldValue ); @Override boolean equals( final Object o ); }### Answer: @Test public void T_getStructFieldsDataAsList_1() throws IOException{ MDSStructObjectInspector inspector = new MDSStructObjectInspector( getTypeInfo() ); Map<String,Object> dataContainer = new HashMap<String,Object>(); dataContainer.put( "str" , new StringObj( "a" ) ); dataContainer.put( "num" , new IntegerObj( 1 ) ); dataContainer.put( "uni" , new IntegerObj( 1 ) ); Spread spread = new Spread(); spread.addRow( dataContainer ); SpreadColumn spreadColumn = new SpreadColumn( "root" ); spreadColumn.setSpread( spread ); ColumnAndIndex columnAndIndex = new ColumnAndIndex( spreadColumn , 0 , 0 ); List<Object> result = inspector.getStructFieldsDataAsList( columnAndIndex ); assertEquals( result.get(0) , new Text( "a" ) ); assertEquals( result.get(1) , new IntWritable( 1 ) ); assertTrue( result.get(2) instanceof ColumnAndIndex ); assertTrue( result.get(3) instanceof StandardUnion ); }
### Question: MakeMDSFileStep1 { public static void main( final String[] args ) throws IOException{ new MakeMDSFileStep1().run(); } private MakeMDSFileStep1(); int run(); static void main( final String[] args ); }### Answer: @Test public void T_run_1() throws IOException{ MakeMDSFileStep1.main( null ); }
### Question: UseSpreadStep4 { public static void main( final String[] args ) throws IOException{ new UseSpreadStep4().run(); } private UseSpreadStep4(); int run(); static void main( final String[] args ); }### Answer: @Test public void T_run_1() throws IOException{ UseSpreadStep4.main( new String[0] ); }
### Question: LoadDataToSpreadStep1 { public static void main( final String[] args ) throws IOException{ new LoadDataToSpreadStep1().run(); } private LoadDataToSpreadStep1(); int run(); static void main( final String[] args ); }### Answer: @Test public void T_run_1() throws IOException{ LoadDataToSpreadStep1.main( null ); }
### Question: UseExpandSpread1 { public static void main( final String[] args ) throws IOException{ new UseExpandSpread1().run(); } private UseExpandSpread1(); int run(); static void main( final String[] args ); }### Answer: @Test public void T_run_1() throws IOException{ UseExpandSpread1.main( new String[0] ); }
### Question: UseSpreadStep2 { public static void main( final String[] args ) throws IOException{ new UseSpreadStep2().run(); } private UseSpreadStep2(); int run(); static void main( final String[] args ); }### Answer: @Test public void T_run_1() throws IOException{ UseSpreadStep2.main( new String[0] ); }
### Question: UseSpreadStep1 { public static void main( final String[] args ) throws IOException{ new UseSpreadStep1().run(); } private UseSpreadStep1(); int run(); static void main( final String[] args ); }### Answer: @Test public void T_run_1() throws IOException{ UseSpreadStep1.main( new String[0] ); }
### Question: UseSpreadStep3 { public static void main( final String[] args ) throws IOException{ new UseSpreadStep3().run(); } private UseSpreadStep3(); int run(); static void main( final String[] args ); }### Answer: @Test public void T_run_1() throws IOException{ UseSpreadStep3.main( new String[0] ); }
### Question: HiveReaderSetting implements IReaderSetting { @Override public Configuration getReaderConfig(){ return config; } HiveReaderSetting( final Configuration config , final IExpressionNode node , final boolean isVectorModeFlag , final boolean disableSkipBlock , final boolean disableFilterPushdown ); HiveReaderSetting( final FileSplit split, final JobConf job ); String createReadColumnNames( final String readColumnNames ); IExpressionNode createExpressionNode( final List<ExprNodeGenericFuncDesc> filterExprs ); Set<String> createPathSet( final Path target ); @Override boolean isVectorMode(); @Override boolean isDisableSkipBlock(); @Override boolean isDisableFilterPushdown(); @Override Configuration getReaderConfig(); @Override IExpressionNode getExpressionNode(); }### Answer: @Test public void T_getReaderConfig_1(){ HiveReaderSetting setting = new HiveReaderSetting( null , null , true , false , false ); assertEquals( null , setting.getReaderConfig() ); }
### Question: FloatRangeBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_FLOAT; } FloatRangeBlockIndex(); FloatRangeBlockIndex( final Float min , final Float max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); Float getMin(); Float getMax(); }### Answer: @Test public void T_getBlockIndexType_1(){ IBlockIndex bIndex = new FloatRangeBlockIndex(); assertEquals( BlockIndexType.RANGE_FLOAT , bIndex.getBlockIndexType() ); }
### Question: HiveReaderSetting implements IReaderSetting { @Override public IExpressionNode getExpressionNode(){ return node; } HiveReaderSetting( final Configuration config , final IExpressionNode node , final boolean isVectorModeFlag , final boolean disableSkipBlock , final boolean disableFilterPushdown ); HiveReaderSetting( final FileSplit split, final JobConf job ); String createReadColumnNames( final String readColumnNames ); IExpressionNode createExpressionNode( final List<ExprNodeGenericFuncDesc> filterExprs ); Set<String> createPathSet( final Path target ); @Override boolean isVectorMode(); @Override boolean isDisableSkipBlock(); @Override boolean isDisableFilterPushdown(); @Override Configuration getReaderConfig(); @Override IExpressionNode getExpressionNode(); }### Answer: @Test public void T_getExpressionNode_1(){ HiveReaderSetting setting = new HiveReaderSetting( null , null , true , false , false ); assertEquals( null , setting.getExpressionNode() ); }
### 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: 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 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 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: 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: 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: 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: 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 { @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: 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: 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: 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: 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 { @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 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 { 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 { @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: 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); }
### Question: TelemetryGenerator { public static String search(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)); Context eventContext = getContext(context); 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 = generateSearchEdata(params); Telemetry telemetry = new Telemetry(TelemetryEvents.SEARCH.getName(), actor, eventContext, edata); 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 testSearch() { String audit = TelemetryGenerator.search(context, params); assertNotNull(audit); }
### Question: TelemetryGenerator { public static String log(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)); Context eventContext = getContext(context); 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 = generateLogEdata(params); Telemetry telemetry = new Telemetry(TelemetryEvents.LOG.getName(), actor, eventContext, edata); 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 testLog() { String audit = TelemetryGenerator.log(context, params); assertNotNull(audit); }
### Question: TelemetryGenerator { public static String error(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)); Context eventContext = getContext(context); 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 = generateErrorEdata(params); Telemetry telemetry = new Telemetry(TelemetryEvents.ERROR.getName(), actor, eventContext, edata); 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 testError() { String audit = TelemetryGenerator.error(context, params); assertNotNull(audit); }
### Question: KeyCloakServiceImpl implements SSOManager { @Override public String getUsernameById(String userId) { String fedUserId = getFederatedUserId(userId); try { UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); UserRepresentation ur = resource.toRepresentation(); return ur.getUsername(); } catch (Exception e) { logger.error("KeyCloakServiceImpl:getUsernameById: User not found for userId = " + userId, e); } logger.info("getUsernameById: User not found for userId = " + userId); return ""; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); }### Answer: @Test public void testGetUsernameById() { String result = keyCloakService.getUsernameById("1234-567-890"); Assert.assertNotNull(result); }
### Question: KeyCloakServiceImpl implements SSOManager { @Override public String deactivateUser(Map<String, Object> request, RequestContext context) { String userId = (String) request.get(JsonKey.USER_ID); makeUserActiveOrInactive(userId, false, context); return JsonKey.SUCCESS; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); }### Answer: @Test(expected = ProjectCommonException.class) public void testDeactivateUserSuccess() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USER_ID, "123"); request.put(JsonKey.FIRST_NAME, userName); keyCloakService.deactivateUser(request, null); }
### Question: KeyCloakServiceImpl implements SSOManager { @Override public String removeUser(Map<String, Object> request, RequestContext context) { Keycloak keycloak = KeyCloakConnectionProvider.getConnection(); String userId = (String) request.get(JsonKey.USER_ID); try { String fedUserId = getFederatedUserId(userId); UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); if (isNotNull(resource)) { resource.remove(); } } catch (Exception ex) { logger.error(context, "Error occurred : ", ex); ProjectUtil.createAndThrowInvalidUserDataException(); } return JsonKey.SUCCESS; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); }### Answer: @Test(expected = ProjectCommonException.class) public void testRemoveUserSuccess() { Map<String, Object> request = new HashMap<String, Object>(); request.put(JsonKey.USER_ID, "123"); keyCloakService.removeUser(request, null); }
### Question: KeyCloakServiceImpl implements SSOManager { @Override public String getLastLoginTime(String userId) { String lastLoginTime = null; try { String fedUserId = getFederatedUserId(userId); UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); UserRepresentation ur = resource.toRepresentation(); Map<String, List<String>> map = ur.getAttributes(); if (map == null) { map = new HashMap<>(); } List<String> list = map.get(JsonKey.LAST_LOGIN_TIME); if (list != null && !list.isEmpty()) { lastLoginTime = list.get(0); } } catch (Exception e) { logger.error(e.getMessage(), e); } return lastLoginTime; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); }### Answer: @Test public void testGetLastLoginTimeSuccess() { String lastLoginTime = keyCloakService.getLastLoginTime(userId.get(JsonKey.USER_ID)); Assert.assertNull(lastLoginTime); }
### Question: KeyCloakServiceImpl implements SSOManager { @Override public String activateUser(Map<String, Object> request, RequestContext context) { String userId = (String) request.get(JsonKey.USER_ID); makeUserActiveOrInactive(userId, true, context); return JsonKey.SUCCESS; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); }### Answer: @Test public void testActivateUserFailureWithEmptyUserId() { Map<String, Object> reqMap = new HashMap<>(); reqMap.put(JsonKey.USER_ID, ""); try { keyCloakService.activateUser(reqMap, null); } catch (ProjectCommonException e) { Assert.assertEquals(ResponseCode.invalidUsrData.getErrorCode(), e.getCode()); Assert.assertEquals(ResponseCode.invalidUsrData.getErrorMessage(), e.getMessage()); Assert.assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); } }
### Question: KeyCloakServiceImpl implements SSOManager { @Override public boolean isEmailVerified(String userId) { String fedUserId = getFederatedUserId(userId); UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); if (isNull(resource)) { return false; } return resource.toRepresentation().isEmailVerified(); } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); }### Answer: @Test public void testIsEmailVerifiedSuccess() { boolean response = keyCloakService.isEmailVerified(userId.get(JsonKey.USER_ID)); Assert.assertEquals(false, response); }
### Question: KeyCloakServiceImpl implements SSOManager { @Override public String setEmailVerifiedTrue(String userId) { updateEmailVerifyStatus(userId, true); return JsonKey.SUCCESS; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); }### Answer: @Test public void testSetEmailVerifiedSuccessWithVerifiedTrue() { String response = keyCloakService.setEmailVerifiedTrue(userId.get(JsonKey.USER_ID)); Assert.assertEquals(JsonKey.SUCCESS, response); }
### Question: MigrationUtils { public static boolean updateRecord( Map<String, Object> propertiesMap, String channel, String userExtId, RequestContext context) { Map<String, Object> compositeKeysMap = new HashMap<>(); compositeKeysMap.put(JsonKey.USER_EXT_ID, userExtId); compositeKeysMap.put(JsonKey.CHANNEL, channel); Response response = cassandraOperation.updateRecord( JsonKey.SUNBIRD, JsonKey.SHADOW_USER, propertiesMap, compositeKeysMap, context); logger.info( context, "MigrationUtils:updateRecord:update in cassandra with userExtId" + userExtId + ":and response is:" + response); return true; } 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 testUpdateRecord() { Map<String, Object> compositeKeysMap = new HashMap<>(); compositeKeysMap.put(JsonKey.USER_EXT_ID, "anyUserExtId"); compositeKeysMap.put(JsonKey.CHANNEL, "anyChannel"); when(cassandraOperationImpl.updateRecord( JsonKey.SUNBIRD, JsonKey.SHADOW_USER, new HashMap<>(), compositeKeysMap, null)) .thenReturn(response); boolean isRecordUpdated = MigrationUtils.updateRecord(new HashMap<>(), "anyChannel", "anyUserExtId", null); Assert.assertEquals(true, isRecordUpdated); }
### Question: KeyCloakServiceImpl implements SSOManager { @Override public boolean doPasswordUpdate(String userId, String password) { boolean response = false; try { String fedUserId = getFederatedUserId(userId); UserResource resource = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); CredentialRepresentation newCredential = new CredentialRepresentation(); newCredential.setValue(password); newCredential.setType(CredentialRepresentation.PASSWORD); newCredential.setTemporary(true); resource.resetPassword(newCredential); response = true; } catch (Exception ex) { logger.error(ex.getMessage(), ex); } return response; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); }### Answer: @Test public void testDoPasswordUpdateSuccess() { boolean response = keyCloakService.doPasswordUpdate(userId.get(JsonKey.USER_ID), "password"); Assert.assertEquals(true, response); }
### Question: KeyCloakServiceImpl implements SSOManager { @Override public boolean updatePassword(String userId, String password, RequestContext context) { try { String fedUserId = getFederatedUserId(userId); UserResource ur = keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(fedUserId); CredentialRepresentation cr = new CredentialRepresentation(); cr.setType(CredentialRepresentation.PASSWORD); cr.setValue(password); ur.resetPassword(cr); return true; } catch (Exception e) { logger.error(context, "updatePassword: Exception occurred: ", e); } return false; } PublicKey getPublicKey(); @Override String verifyToken(String accessToken, RequestContext context); @Override boolean updatePassword(String userId, String password, RequestContext context); @Override String updateUser(Map<String, Object> request, RequestContext context); @Override String syncUserData(Map<String, Object> request); @Override String removeUser(Map<String, Object> request, RequestContext context); @Override String deactivateUser(Map<String, Object> request, RequestContext context); @Override String activateUser(Map<String, Object> request, RequestContext context); @Override boolean isEmailVerified(String userId); @Override void setEmailVerifiedUpdatedFlag(String userId, String flag); @Override String getEmailVerifiedUpdatedFlag(String userId); @Override boolean doPasswordUpdate(String userId, String password); @Override String getLastLoginTime(String userId); @Override boolean addUserLoginTime(String userId); @Override String setEmailVerifiedTrue(String userId); @Override String setEmailVerifiedAsFalse(String userId); @Override void setRequiredAction(String userId, String requiredAction); @Override String getUsernameById(String userId); @Override String verifyToken(String accessToken, String url, RequestContext context); }### Answer: @Test public void testUpdatePassword() throws Exception { boolean updated = keyCloakService.updatePassword(userId.get(JsonKey.USER_ID), "password", null); Assert.assertTrue(updated); }
### Question: CloudStorageUtil { public static String upload( CloudStorageType storageType, String container, String objectKey, String filePath) { IStorageService storageService = getStorageService(storageType); return storageService.upload( container, filePath, objectKey, Option.apply(false), Option.apply(1), Option.apply(STORAGE_SERVICE_API_RETRY_COUNT), Option.empty()); } static String upload( CloudStorageType storageType, String container, String objectKey, String filePath); static String getSignedUrl( CloudStorageType storageType, String container, String objectKey); static String getAnalyticsSignedUrl( CloudStorageType storageType, String container, String objectKey); static String getSignedUrl( IStorageService storageService, CloudStorageType storageType, String container, String objectKey); static String getUri( CloudStorageType storageType, String container, String prefix, boolean isDirectory); }### Answer: @Test @Ignore public void testUploadSuccess() { String result = CloudStorageUtil.upload(CloudStorageType.AZURE, "container", "key", "/file/path"); assertTrue(UPLOAD_URL.equals(result)); }
### Question: MigrationUtils { public static boolean markUserAsRejected(ShadowUser shadowUser, RequestContext context) { Map<String, Object> propertiesMap = new HashMap<>(); propertiesMap.put(JsonKey.CLAIM_STATUS, ClaimStatus.REJECTED.getValue()); propertiesMap.put(JsonKey.UPDATED_ON, new Timestamp(System.currentTimeMillis())); boolean isRecordUpdated = updateRecord(propertiesMap, shadowUser.getChannel(), shadowUser.getUserExtId(), context); logger.info( context, "MigrationUtils:markUserAsRejected:update in cassandra with userExtId" + shadowUser.getUserExtId()); return isRecordUpdated; } 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 testmarkUserAsRejected() { ShadowUser shadowUser = new ShadowUser.ShadowUserBuilder() .setChannel("anyChannel") .setUserExtId("anyUserExtId") .build(); Map<String, Object> compositeKeysMap = new HashMap<>(); compositeKeysMap.put(JsonKey.USER_EXT_ID, "anyUserExtId"); compositeKeysMap.put(JsonKey.CHANNEL, "anyChannel"); when(cassandraOperationImpl.updateRecord( JsonKey.SUNBIRD, JsonKey.SHADOW_USER, new HashMap<>(), compositeKeysMap, null)) .thenReturn(response); boolean isRecordUpdated = MigrationUtils.markUserAsRejected(shadowUser, null); Assert.assertEquals(true, isRecordUpdated); }
### Question: CloudStorageUtil { public static String getSignedUrl( CloudStorageType storageType, String container, String objectKey) { IStorageService storageService = getStorageService(storageType); return getSignedUrl(storageService, storageType, container, objectKey); } static String upload( CloudStorageType storageType, String container, String objectKey, String filePath); static String getSignedUrl( CloudStorageType storageType, String container, String objectKey); static String getAnalyticsSignedUrl( CloudStorageType storageType, String container, String objectKey); static String getSignedUrl( IStorageService storageService, CloudStorageType storageType, String container, String objectKey); static String getUri( CloudStorageType storageType, String container, String prefix, boolean isDirectory); }### Answer: @Test @Ignore public void testGetSignedUrlSuccess() { String signedUrl = CloudStorageUtil.getSignedUrl(CloudStorageType.AZURE, "container", "key"); assertTrue(SIGNED_URL.equals(signedUrl)); }
### Question: RequestValidator { public static void validateRegisterClient(Request request) { if (StringUtils.isBlank((String) request.getRequest().get(JsonKey.CLIENT_NAME))) { throw createExceptionInstance(ResponseCode.invalidClientName.getErrorCode()); } } private RequestValidator(); static void validateUploadUser(Map<String, Object> reqObj); static void validateSyncRequest(Request request); static void validateSendMail(Request request); static void validateFileUpload(Request reqObj); static void validateCreateOrgType(Request reqObj); static void validateUpdateOrgType(Request reqObj); @SuppressWarnings("rawtypes") static void validateNote(Request request); static void validateNoteId(String noteId); static void validateRegisterClient(Request request); static void validateUpdateClientKey(String clientId, String masterAccessToken); static void validateGetClientKey(String id, String type); static void validateClientId(String clientId); @SuppressWarnings("unchecked") static void validateSendNotification(Request request); @SuppressWarnings("rawtypes") static void validateGetUserCount(Request request); }### Answer: @Test public void testValidateRegisterClientFailureWithEmptyClientName() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.CLIENT_NAME, ""); request.setRequest(requestObj); try { RequestValidator.validateRegisterClient(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidClientName.getErrorCode(), e.getCode()); } } @Test public void testValidateRegisterClientSuccess() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.CLIENT_NAME, "1234"); request.setRequest(requestObj); try { RequestValidator.validateRegisterClient(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidClientName.getErrorCode(), e.getCode()); } }
### Question: MigrationUtils { public static boolean updateClaimStatus( ShadowUser shadowUser, int claimStatus, RequestContext context) { Map<String, Object> propertiesMap = new WeakHashMap<>(); propertiesMap.put(JsonKey.CLAIM_STATUS, claimStatus); propertiesMap.put(JsonKey.UPDATED_ON, new Timestamp(System.currentTimeMillis())); updateRecord(propertiesMap, shadowUser.getChannel(), shadowUser.getUserExtId(), context); logger.info( context, "MigrationUtils:markUserAsRejected:update in cassandra with userExtId" + shadowUser.getUserExtId()); return true; } 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 testUpdateClaimStatus() { ShadowUser shadowUser = new ShadowUser.ShadowUserBuilder() .setChannel("anyChannel") .setUserExtId("anyUserExtId") .build(); Map<String, Object> compositeKeysMap = new HashMap<>(); compositeKeysMap.put(JsonKey.USER_EXT_ID, "anyUserExtId"); compositeKeysMap.put(JsonKey.CHANNEL, "anyChannel"); when(cassandraOperationImpl.updateRecord( JsonKey.SUNBIRD, JsonKey.SHADOW_USER, new HashMap<>(), compositeKeysMap, null)) .thenReturn(response); boolean isRecordUpdated = MigrationUtils.updateClaimStatus(shadowUser, ClaimStatus.ELIGIBLE.getValue(), null); Assert.assertEquals(true, isRecordUpdated); }
### Question: RequestValidator { public static void validateUpdateClientKey(String clientId, String masterAccessToken) { validateClientId(clientId); if (StringUtils.isBlank(masterAccessToken)) { throw createExceptionInstance(ResponseCode.invalidRequestData.getErrorCode()); } } private RequestValidator(); static void validateUploadUser(Map<String, Object> reqObj); static void validateSyncRequest(Request request); static void validateSendMail(Request request); static void validateFileUpload(Request reqObj); static void validateCreateOrgType(Request reqObj); static void validateUpdateOrgType(Request reqObj); @SuppressWarnings("rawtypes") static void validateNote(Request request); static void validateNoteId(String noteId); static void validateRegisterClient(Request request); static void validateUpdateClientKey(String clientId, String masterAccessToken); static void validateGetClientKey(String id, String type); static void validateClientId(String clientId); @SuppressWarnings("unchecked") static void validateSendNotification(Request request); @SuppressWarnings("rawtypes") static void validateGetUserCount(Request request); }### Answer: @Test public void testValidateUpdateClientKeyFailureWithEmptyToken() { try { RequestValidator.validateUpdateClientKey("1234", ""); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidRequestData.getErrorCode(), e.getCode()); } } @Test public void testValidateUpdateClientKeySuccess() { try { RequestValidator.validateUpdateClientKey("1234", "test123"); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidRequestData.getErrorCode(), e.getCode()); } }
### Question: RequestValidator { public static void validateClientId(String clientId) { if (StringUtils.isBlank(clientId)) { throw createExceptionInstance(ResponseCode.invalidClientId.getErrorCode()); } } private RequestValidator(); static void validateUploadUser(Map<String, Object> reqObj); static void validateSyncRequest(Request request); static void validateSendMail(Request request); static void validateFileUpload(Request reqObj); static void validateCreateOrgType(Request reqObj); static void validateUpdateOrgType(Request reqObj); @SuppressWarnings("rawtypes") static void validateNote(Request request); static void validateNoteId(String noteId); static void validateRegisterClient(Request request); static void validateUpdateClientKey(String clientId, String masterAccessToken); static void validateGetClientKey(String id, String type); static void validateClientId(String clientId); @SuppressWarnings("unchecked") static void validateSendNotification(Request request); @SuppressWarnings("rawtypes") static void validateGetUserCount(Request request); }### Answer: @Test public void testValidateClientIdFailureWithEmptyId() { try { RequestValidator.validateClientId(""); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidClientId.getErrorCode(), e.getCode()); } }
### Question: RequestValidator { public static void validateFileUpload(Request reqObj) { if (StringUtils.isBlank((String) reqObj.get(JsonKey.CONTAINER))) { throw new ProjectCommonException( ResponseCode.storageContainerNameMandatory.getErrorCode(), ResponseCode.storageContainerNameMandatory.getErrorMessage(), ERROR_CODE); } } private RequestValidator(); static void validateUploadUser(Map<String, Object> reqObj); static void validateSyncRequest(Request request); static void validateSendMail(Request request); static void validateFileUpload(Request reqObj); static void validateCreateOrgType(Request reqObj); static void validateUpdateOrgType(Request reqObj); @SuppressWarnings("rawtypes") static void validateNote(Request request); static void validateNoteId(String noteId); static void validateRegisterClient(Request request); static void validateUpdateClientKey(String clientId, String masterAccessToken); static void validateGetClientKey(String id, String type); static void validateClientId(String clientId); @SuppressWarnings("unchecked") static void validateSendNotification(Request request); @SuppressWarnings("rawtypes") static void validateGetUserCount(Request request); }### Answer: @Test public void testValidateFileUploadFailureWithoutContainerName() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.CONTAINER, ""); request.setRequest(requestObj); try { RequestValidator.validateFileUpload(request); } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.storageContainerNameMandatory.getErrorCode(), e.getCode()); } }
### Question: RequestValidator { public static void validateCreateOrgType(Request reqObj) { if (StringUtils.isBlank((String) reqObj.getRequest().get(JsonKey.NAME))) { throw createExceptionInstance(ResponseCode.orgTypeMandatory.getErrorCode()); } } private RequestValidator(); static void validateUploadUser(Map<String, Object> reqObj); static void validateSyncRequest(Request request); static void validateSendMail(Request request); static void validateFileUpload(Request reqObj); static void validateCreateOrgType(Request reqObj); static void validateUpdateOrgType(Request reqObj); @SuppressWarnings("rawtypes") static void validateNote(Request request); static void validateNoteId(String noteId); static void validateRegisterClient(Request request); static void validateUpdateClientKey(String clientId, String masterAccessToken); static void validateGetClientKey(String id, String type); static void validateClientId(String clientId); @SuppressWarnings("unchecked") static void validateSendNotification(Request request); @SuppressWarnings("rawtypes") static void validateGetUserCount(Request request); }### Answer: @Test public void testValidateCreateOrgTypeSuccess() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.NAME, "OrgTypeName"); request.setRequest(requestObj); boolean response = false; try { RequestValidator.validateCreateOrgType(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } Assert.assertTrue(response); } @Test public void testValidateCreateOrgTypeFailureWithNullName() { Request request = new Request(); Map<String, Object> requestObj = new HashMap<>(); requestObj.put(JsonKey.NAME, null); request.setRequest(requestObj); boolean response = false; try { RequestValidator.validateCreateOrgType(request); response = true; } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.orgTypeMandatory.getErrorCode(), e.getCode()); } Assert.assertFalse(response); }
### Question: RequestValidator { public static void validateGetClientKey(String id, String type) { validateClientId(id); if (StringUtils.isBlank(type)) { throw createExceptionInstance(ResponseCode.invalidRequestData.getErrorCode()); } } private RequestValidator(); static void validateUploadUser(Map<String, Object> reqObj); static void validateSyncRequest(Request request); static void validateSendMail(Request request); static void validateFileUpload(Request reqObj); static void validateCreateOrgType(Request reqObj); static void validateUpdateOrgType(Request reqObj); @SuppressWarnings("rawtypes") static void validateNote(Request request); static void validateNoteId(String noteId); static void validateRegisterClient(Request request); static void validateUpdateClientKey(String clientId, String masterAccessToken); static void validateGetClientKey(String id, String type); static void validateClientId(String clientId); @SuppressWarnings("unchecked") static void validateSendNotification(Request request); @SuppressWarnings("rawtypes") static void validateGetUserCount(Request request); }### Answer: @Test public void testValidateGetClientKeySuccess() { boolean response = false; try { RequestValidator.validateGetClientKey("clientId", "clientType"); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } Assert.assertTrue(response); } @Test public void testValidateGetClientKeyFailureWithEmptyClientId() { boolean response = false; try { RequestValidator.validateGetClientKey("", "clientType"); response = true; } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidClientId.getErrorCode(), e.getCode()); } Assert.assertFalse(response); } @Test public void testValidateGetClientKeyFailureWithEmptyClientType() { boolean response = false; try { RequestValidator.validateGetClientKey("clientId", ""); response = true; } catch (ProjectCommonException e) { assertEquals(ResponseCode.CLIENT_ERROR.getResponseCode(), e.getResponseCode()); assertEquals(ResponseCode.invalidRequestData.getErrorCode(), e.getCode()); } Assert.assertFalse(response); }
### Question: UserRequestValidator extends BaseRequestValidator { public void validateCreateUserV3Request(Request userRequest) { validateCreateUserRequest(userRequest); } void validateCreateUserRequest(Request userRequest); static boolean isGoodPassword(String password); void validateUserCreateV3(Request userRequest); void validateCreateUserV3Request(Request userRequest); void validateUserCreateV4(Request userRequest); void validateCreateUserV1Request(Request userRequest); void validateCreateUserV2Request(Request userRequest); void fieldsNotAllowed(List<String> fields, Request userRequest); void phoneValidation(Request userRequest); void createUserBasicValidation(Request userRequest); void validateUpdateUserRequest(Request userRequest); void externalIdsValidation(Request userRequest, String operation); void validateChangePassword(Request userRequest); void validateVerifyUser(Request userRequest); void validateAssignRole(Request request); void validateForgotPassword(Request request); @SuppressWarnings("unchecked") void validateMandatoryFrameworkFields( Map<String, Object> userMap, List<String> frameworkFields, List<String> frameworkMandatoryFields); @SuppressWarnings("unchecked") void validateFrameworkCategoryValues( Map<String, Object> userMap, Map<String, List<Map<String, String>>> frameworkMap); void validateUserMergeRequest( Request request, String authUserToken, String sourceUserToken); void validateCertValidationRequest(Request request); void validateUserId(String uuid); void validateUserDeclarationRequest(Request userDeclareRequest); }### Answer: @Test public void testValidateValidateCreateUserV3RequestSuccess() { boolean response = false; Request request = initailizeRequest(); Map<String, Object> requestObj = request.getRequest(); requestObj.put(JsonKey.PASSWORD, "Password@1"); request.setRequest(requestObj); try { userRequestValidator.validateCreateUserV3Request(request); response = true; } catch (ProjectCommonException e) { Assert.assertNull(e); } assertEquals(true, response); }

Subsets and Splits

No saved queries yet

Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.