method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
SVGBasicShapeViewImpl extends WiresShapeView<SVGBasicShapeViewImpl> implements SVGBasicShapeView<SVGBasicShapeViewImpl> { @Override public SVGBasicShapeViewImpl addChild(final SVGPrimitive<?> child) { childViewHandler.addChild(child); return this; } SVGBasicShapeViewImpl(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height); @Override String getName(); @Override Shape<?> getShape(); @Override SVGBasicShapeViewImpl addChild(final SVGPrimitive<?> child); @Override Collection<SVGPrimitive<?>> getChildren(); @Override SVGPrimitive getPrimitive(); @Override @SuppressWarnings("unchecked") SVGBasicShapeViewImpl addSVGChild(final SVGContainer parent,
final SVGBasicShapeView child); @Override Collection<SVGBasicShapeView> getSVGChildren(); @Override void destroy(); }### Answer:
@Test public void testAddChild() { tested.addChild(childShape); final Collection<SVGPrimitive<?>> svgChildren = tested.getChildren(); assertEquals(1, svgChildren.size()); assertEquals(childShape, svgChildren.iterator().next()); } |
### Question:
SVGShapeViewImpl extends DecoratedShapeView<SVGShapeViewImpl> implements SVGShapeView<SVGShapeViewImpl> { @Override public SVGShapeViewImpl addChild(final SVGPrimitive<?> child) { childViewHandler.addChild(child); return this; } @SuppressWarnings("unchecked") SVGShapeViewImpl(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); @Override String getName(); @Override SVGPrimitive getPrimitive(); @Override SVGShapeViewImpl addChild(final SVGPrimitive<?> child); @Override SVGShapeViewImpl addSVGChild(final SVGContainer parent,
final SVGBasicShapeView child); @Override void destroy(); @Override Collection<SVGPrimitive<?>> getChildren(); @Override Collection<SVGBasicShapeView> getSVGChildren(); ShapeStateDefaultHandler getShapeStateHandler(); @Override void applyState(final ShapeState shapeState); }### Answer:
@Test public void testAddChild() { tested.addChild(childShape); final Collection<SVGPrimitive<?>> svgChildren = tested.getChildren(); assertEquals(1, svgChildren.size()); assertEquals(childShape, svgChildren.iterator().next()); } |
### Question:
SVGChildViewHandler { @SuppressWarnings("unchecked") public void addSVGChild(final SVGContainer parent, final SVGBasicShapeView child) { if (!hasSvgChild(child)) { svgChildren.add(child); parent.addPrimitive((IPrimitive<?>) child.getContainer()); } } SVGChildViewHandler(final WiresShapeView<?> view); @SuppressWarnings("unchecked") void addChild(final SVGPrimitive<?> child); @SuppressWarnings("unchecked") void addSVGChild(final SVGContainer parent,
final SVGBasicShapeView child); void clear(); Collection<SVGPrimitive<?>> getChildren(); Collection<SVGBasicShapeView> getSVGChildren(); }### Answer:
@Test public void testAddSVGChild() { tested.addSVGChild(parentShape, svgChild); assertEquals(svgGroup, parentShape.getPrimitive("svgGroup1")); assertEquals(1, tested.getSVGChildren().size()); assertEquals(svgChild, tested.getSVGChildren().iterator().next()); } |
### Question:
SVGChildViewHandler { @SuppressWarnings("unchecked") public void addChild(final SVGPrimitive<?> child) { final IPrimitive<?> primitive = child.get(); primChildren.add(child); if (child.isScalable() && view instanceof DecoratedShapeView) { ((DecoratedShapeView) view).addScalableChild(primitive); } else if (null != child.getLayout()) { view.addChild(primitive, child.getLayout()); } else { view.addChild(primitive); } } SVGChildViewHandler(final WiresShapeView<?> view); @SuppressWarnings("unchecked") void addChild(final SVGPrimitive<?> child); @SuppressWarnings("unchecked") void addSVGChild(final SVGContainer parent,
final SVGBasicShapeView child); void clear(); Collection<SVGPrimitive<?>> getChildren(); Collection<SVGBasicShapeView> getSVGChildren(); }### Answer:
@Test public void testAddChild() { primitiveShape = new SVGPrimitiveShape(rectangle); tested.addChild(primitiveShape); verify(shapeView, times(1)).addChild(eq(rectangle)); assertEquals(1, tested.getChildren().size()); assertEquals(primitiveShape, tested.getChildren().iterator().next()); } |
### Question:
SVGViewUtils { public static void switchVisibility(final SVGShapeView<?> view, final String visibleId, final String nonVisibleId) { getPrimitive(view, visibleId) .ifPresent(prim -> prim.get().setAlpha(1)); getPrimitive(view, nonVisibleId) .ifPresent(prim -> prim.get().setAlpha(0)); } static void switchVisibility(final SVGShapeView<?> view,
final String visibleId,
final String nonVisibleId); @SuppressWarnings("unchecked") static V getVisibleShape(final ShapeView<?>... views); static Optional<SVGPrimitive> getPrimitive(final SVGShapeView<?> view,
final String id); static SVGPrimitive getPrimitive(final SVGContainer container,
final String id); static SVGPrimitive getPrimitive(final Collection<SVGPrimitive<?>> primitives,
final String id); static SVGPrimitive getPrimitive(final SVGPrimitive<?> primitive,
final String id); static void setFillAndStroke(final SVGShapeView<?> view, final String id, final double fill, final double stroke); }### Answer:
@Test public void testSwitchVisibilityP1P2() { SVGViewUtils.switchVisibility(svgShape, "p1", "p2"); verify(p1, times(1)).setAlpha(1d); verify(p2, times(1)).setAlpha(0d); }
@Test public void testSwitchVisibilityP2P1() { SVGViewUtils.switchVisibility(svgShape, "p2", "p1"); verify(p1, times(1)).setAlpha(0d); verify(p2, times(1)).setAlpha(1d); } |
### Question:
SVGViewUtils { public static Optional<SVGPrimitive> getPrimitive(final SVGShapeView<?> view, final String id) { return Optional.ofNullable(getPrimitive(view.getChildren(), id)); } static void switchVisibility(final SVGShapeView<?> view,
final String visibleId,
final String nonVisibleId); @SuppressWarnings("unchecked") static V getVisibleShape(final ShapeView<?>... views); static Optional<SVGPrimitive> getPrimitive(final SVGShapeView<?> view,
final String id); static SVGPrimitive getPrimitive(final SVGContainer container,
final String id); static SVGPrimitive getPrimitive(final Collection<SVGPrimitive<?>> primitives,
final String id); static SVGPrimitive getPrimitive(final SVGPrimitive<?> primitive,
final String id); static void setFillAndStroke(final SVGShapeView<?> view, final String id, final double fill, final double stroke); }### Answer:
@Test public void testGetPrimitive() { Optional<SVGPrimitive> r1 = SVGViewUtils.getPrimitive(svgShape, "p1"); assertTrue(r1.isPresent()); assertEquals(primitive1, r1.get()); assertEquals(p1, r1.get().get()); Optional<SVGPrimitive> r2 = SVGViewUtils.getPrimitive(svgShape, "p2"); assertTrue(r2.isPresent()); assertEquals(primitive2, r2.get()); assertEquals(p2, r2.get().get()); } |
### Question:
SVGViewUtils { @SuppressWarnings("unchecked") public static <V extends ShapeView<?>> V getVisibleShape(final ShapeView<?>... views) { for (ShapeView<?> view : views) { if (view.getAlpha() > 0) { return (V) view; } } return null; } static void switchVisibility(final SVGShapeView<?> view,
final String visibleId,
final String nonVisibleId); @SuppressWarnings("unchecked") static V getVisibleShape(final ShapeView<?>... views); static Optional<SVGPrimitive> getPrimitive(final SVGShapeView<?> view,
final String id); static SVGPrimitive getPrimitive(final SVGContainer container,
final String id); static SVGPrimitive getPrimitive(final Collection<SVGPrimitive<?>> primitives,
final String id); static SVGPrimitive getPrimitive(final SVGPrimitive<?> primitive,
final String id); static void setFillAndStroke(final SVGShapeView<?> view, final String id, final double fill, final double stroke); }### Answer:
@Test public void testGetVisibleShape() { when(shape1.getAlpha()).thenReturn(0d); when(shape2.getAlpha()).thenReturn(0.1d); ShapeView<?> visibleShape = SVGViewUtils.getVisibleShape(shape1, shape2); assertEquals(shape2, visibleShape); when(shape1.getAlpha()).thenReturn(0.1d); when(shape2.getAlpha()).thenReturn(0d); visibleShape = SVGViewUtils.getVisibleShape(shape1, shape2); assertEquals(shape1, visibleShape); } |
### Question:
SVGViewUtils { public static void setFillAndStroke(final SVGShapeView<?> view, final String id, final double fill, final double stroke) { SVGViewUtils.getPrimitive(view, id).ifPresent(p -> p.get().setFillAlpha(fill).setStrokeAlpha(stroke)); } static void switchVisibility(final SVGShapeView<?> view,
final String visibleId,
final String nonVisibleId); @SuppressWarnings("unchecked") static V getVisibleShape(final ShapeView<?>... views); static Optional<SVGPrimitive> getPrimitive(final SVGShapeView<?> view,
final String id); static SVGPrimitive getPrimitive(final SVGContainer container,
final String id); static SVGPrimitive getPrimitive(final Collection<SVGPrimitive<?>> primitives,
final String id); static SVGPrimitive getPrimitive(final SVGPrimitive<?> primitive,
final String id); static void setFillAndStroke(final SVGShapeView<?> view, final String id, final double fill, final double stroke); }### Answer:
@Test public void testSetFillAndStroke() { double fillAlpha = 123; double strokeAlpha = 456; when(p1.setFillAlpha(anyDouble())).thenReturn(p1); when(p1.setStrokeAlpha(anyDouble())).thenReturn(p1); SVGViewUtils.setFillAndStroke(svgShape, "p1", fillAlpha, strokeAlpha); verify(p1).setFillAlpha(fillAlpha); verify(p1).setStrokeAlpha(strokeAlpha); } |
### Question:
SVGShapeImpl implements SVGShape<SVGShapeViewImpl> { @Override public SVGShapeViewImpl getShapeView() { return view; } @SuppressWarnings("unchecked") SVGShapeImpl(final SVGShapeViewImpl view); @SuppressWarnings("unchecked") SVGShapeImpl(final SVGShapeViewImpl view,
final LienzoShape<LienzoShapeView> shape); @Override void setUUID(final String uuid); @Override String getUUID(); @Override void beforeDraw(); @Override void afterDraw(); @Override void applyState(final ShapeState shapeState); @Override SVGShapeViewImpl getShapeView(); }### Answer:
@Test public void testView() { assertEquals(view, tested.getShapeView()); } |
### Question:
SVGShapeImpl implements SVGShape<SVGShapeViewImpl> { @Override public void beforeDraw() { shape.beforeDraw(); } @SuppressWarnings("unchecked") SVGShapeImpl(final SVGShapeViewImpl view); @SuppressWarnings("unchecked") SVGShapeImpl(final SVGShapeViewImpl view,
final LienzoShape<LienzoShapeView> shape); @Override void setUUID(final String uuid); @Override String getUUID(); @Override void beforeDraw(); @Override void afterDraw(); @Override void applyState(final ShapeState shapeState); @Override SVGShapeViewImpl getShapeView(); }### Answer:
@Test public void testBeforeDraw() { mocked.beforeDraw(); verify(lienzoShape, times(1)).beforeDraw(); verify(lienzoShape, times(0)).afterDraw(); verify(lienzoShape, times(0)).applyState(any(ShapeState.class)); } |
### Question:
SVGShapeImpl implements SVGShape<SVGShapeViewImpl> { @Override public void afterDraw() { shape.afterDraw(); } @SuppressWarnings("unchecked") SVGShapeImpl(final SVGShapeViewImpl view); @SuppressWarnings("unchecked") SVGShapeImpl(final SVGShapeViewImpl view,
final LienzoShape<LienzoShapeView> shape); @Override void setUUID(final String uuid); @Override String getUUID(); @Override void beforeDraw(); @Override void afterDraw(); @Override void applyState(final ShapeState shapeState); @Override SVGShapeViewImpl getShapeView(); }### Answer:
@Test public void testAfterDraw() { mocked.afterDraw(); verify(lienzoShape, times(1)).afterDraw(); verify(lienzoShape, times(0)).beforeDraw(); verify(lienzoShape, times(0)).applyState(any(ShapeState.class)); } |
### Question:
SVGShapeImpl implements SVGShape<SVGShapeViewImpl> { @Override public void applyState(final ShapeState shapeState) { shape.applyState(shapeState); } @SuppressWarnings("unchecked") SVGShapeImpl(final SVGShapeViewImpl view); @SuppressWarnings("unchecked") SVGShapeImpl(final SVGShapeViewImpl view,
final LienzoShape<LienzoShapeView> shape); @Override void setUUID(final String uuid); @Override String getUUID(); @Override void beforeDraw(); @Override void afterDraw(); @Override void applyState(final ShapeState shapeState); @Override SVGShapeViewImpl getShapeView(); }### Answer:
@Test public void testApplyState() { final ShapeState state = ShapeState.SELECTED; mocked.applyState(state); verify(lienzoShape, times(1)).applyState(eq(state)); verify(lienzoShape, times(0)).beforeDraw(); verify(lienzoShape, times(0)).afterDraw(); } |
### Question:
ValidationUtils { public static Violation.Type getMaxSeverity(final Collection<? extends Violation> violations) { final Violation.Type[] type = {Violation.Type.INFO}; violations.forEach(v -> { if (v.getViolationType().getSeverity() > type[0].getSeverity()) { type[0] = v.getViolationType(); } }); return type[0]; } static Violation.Type getMaxSeverity(final Collection<? extends Violation> violations); }### Answer:
@Test @SuppressWarnings("unchecked") public void testGetMaxSeverity() { when(violation1.getViolationType()).thenReturn(Violation.Type.INFO); when(violation2.getViolationType()).thenReturn(Violation.Type.WARNING); when(violation3.getViolationType()).thenReturn(Violation.Type.ERROR); assertEquals(Violation.Type.ERROR, ValidationUtils.getMaxSeverity(violations)); when(violation3.getViolationType()).thenReturn(Violation.Type.INFO); assertEquals(Violation.Type.WARNING, ValidationUtils.getMaxSeverity(violations)); when(violation1.getViolationType()).thenReturn(Violation.Type.ERROR); assertEquals(Violation.Type.ERROR, ValidationUtils.getMaxSeverity(violations)); } |
### Question:
ClassUtils { public boolean isPrimitiveClass(Class<?> type) { return type.isPrimitive() || WRAPPER_MAP.containsKey(type); } ClassUtils(); static boolean isTypeOf(Class<?> type,
Object instance); static String getName(Class<?> type); static boolean isJavaRuntimeClassname(String fqcn); boolean isPrimitiveClass(Class<?> type); }### Answer:
@Test public void isPrimitiveClass() throws Exception { assertTrue(classUtils.isPrimitiveClass(Boolean.class)); assertTrue(classUtils.isPrimitiveClass(Byte.class)); assertTrue(classUtils.isPrimitiveClass(Character.class)); assertTrue(classUtils.isPrimitiveClass(Short.class)); assertTrue(classUtils.isPrimitiveClass(Integer.class)); assertTrue(classUtils.isPrimitiveClass(Long.class)); assertTrue(classUtils.isPrimitiveClass(Double.class)); assertTrue(classUtils.isPrimitiveClass(Float.class)); assertTrue(classUtils.isPrimitiveClass(Void.class)); assertFalse(classUtils.isPrimitiveClass(String.class)); assertFalse(classUtils.isPrimitiveClass(BigInteger.class)); assertFalse(classUtils.isPrimitiveClass(this.getClass())); } |
### Question:
ClassUtils { public static boolean isJavaRuntimeClassname(String fqcn) { return fqcn.startsWith("java"); } ClassUtils(); static boolean isTypeOf(Class<?> type,
Object instance); static String getName(Class<?> type); static boolean isJavaRuntimeClassname(String fqcn); boolean isPrimitiveClass(Class<?> type); }### Answer:
@Test public void TestIsJavaRuntimeClass() { assertTrue(ClassUtils.isJavaRuntimeClassname("java.lang.Object")); assertTrue(ClassUtils.isJavaRuntimeClassname("java.util.HashMap")); assertTrue(ClassUtils.isJavaRuntimeClassname("javax.bind")); assertFalse(ClassUtils.isJavaRuntimeClassname("org.kie")); assertFalse(ClassUtils.isJavaRuntimeClassname("com.google")); } |
### Question:
DefinitionUtils { public <T> String getName(final T definition) { final DefinitionAdapter<Object> definitionAdapter = definitionManager.adapters().registry().getDefinitionAdapter(definition.getClass()); final String nameField = definitionAdapter.getMetaPropertyField(definition, PropertyMetaTypes.NAME); if (null != nameField) { Object name = definitionAdapter.getProperty(definition, nameField).get(); return getPropertyValueAsString(name); } return null; } protected DefinitionUtils(); @Inject @SuppressWarnings("all") DefinitionUtils(final DefinitionManager definitionManager,
final DefinitionsCacheRegistry definitionsRegistry); String getName(final T definition); String getNameIdentifier(final T definition); String getTitle(final String definitionId); @SuppressWarnings("unchecked") Bounds buildBounds(final Object definition,
final double x,
final double y); MorphDefinition getMorphDefinition(final T definition); boolean hasMorphTargets(final Object definition); String getDefinitionSetId(final Class<?> type); String[] getDefinitionIds(final T definition); boolean isAllPolicy(final MorphDefinition definition); boolean isNonePolicy(final MorphDefinition definition); boolean isDefaultPolicy(final MorphDefinition definition); Annotation getQualifier(final String defSetId); static boolean isNodeFactory(final Class<? extends ElementFactory> graphFactoryClass,
final FactoryRegistry registry); static boolean isEdgeFactory(final Class<? extends ElementFactory> graphFactoryClass,
final FactoryRegistry registry); DefinitionManager getDefinitionManager(); static Class<? extends PropertyType> getDefaultPropertyType(final Class<?> clazz); static Object getElementDefinition(final Element element); }### Answer:
@Test @SuppressWarnings("unchecked") public void getNameFromField() { when(graphMockHandler.getPropertyAdapter().getValue(domainObject.getNameProperty())).thenReturn("nameValue"); final String name = tested.getName(domainObject); assertEquals("nameValue", name); } |
### Question:
DefinitionUtils { public <T> String getNameIdentifier(final T definition) { return definitionManager.adapters().forDefinition().getMetaPropertyField(definition, PropertyMetaTypes.NAME); } protected DefinitionUtils(); @Inject @SuppressWarnings("all") DefinitionUtils(final DefinitionManager definitionManager,
final DefinitionsCacheRegistry definitionsRegistry); String getName(final T definition); String getNameIdentifier(final T definition); String getTitle(final String definitionId); @SuppressWarnings("unchecked") Bounds buildBounds(final Object definition,
final double x,
final double y); MorphDefinition getMorphDefinition(final T definition); boolean hasMorphTargets(final Object definition); String getDefinitionSetId(final Class<?> type); String[] getDefinitionIds(final T definition); boolean isAllPolicy(final MorphDefinition definition); boolean isNonePolicy(final MorphDefinition definition); boolean isDefaultPolicy(final MorphDefinition definition); Annotation getQualifier(final String defSetId); static boolean isNodeFactory(final Class<? extends ElementFactory> graphFactoryClass,
final FactoryRegistry registry); static boolean isEdgeFactory(final Class<? extends ElementFactory> graphFactoryClass,
final FactoryRegistry registry); DefinitionManager getDefinitionManager(); static Class<? extends PropertyType> getDefaultPropertyType(final Class<?> clazz); static Object getElementDefinition(final Element element); }### Answer:
@Test public void getNameIdentifier() { final String nameIdentifier = tested.getNameIdentifier(domainObject); assertEquals(TestingSimpleDomainObject.NAME, nameIdentifier); } |
### Question:
EdgeFactoryImpl extends AbstractElementFactory<Object, Definition<Object>, Edge<Definition<Object>, Node>> implements EdgeFactory<Object> { @Override public Class<? extends ElementFactory> getFactoryType() { return EdgeFactory.class; } protected EdgeFactoryImpl(); @Inject EdgeFactoryImpl(final DefinitionManager definitionManager); @Override Class<? extends ElementFactory> getFactoryType(); @Override @SuppressWarnings("unchecked") Edge<Definition<Object>, Node> build(final String uuid,
final Object definition); @Override boolean accepts(final Object source); }### Answer:
@Test public void testType() { assertEquals(EdgeFactory.class, this.tested.getFactoryType()); } |
### Question:
EdgeFactoryImpl extends AbstractElementFactory<Object, Definition<Object>, Edge<Definition<Object>, Node>> implements EdgeFactory<Object> { @Override @SuppressWarnings("unchecked") public Edge<Definition<Object>, Node> build(final String uuid, final Object definition) { final EdgeImpl edge = new EdgeImpl<>(uuid); if (null != definition) { ViewConnector<Object> content = new ViewConnectorImpl<>(definition, buildBounds()); edge.setContent(content); appendLabels(edge.getLabels(), definition); } return edge; } protected EdgeFactoryImpl(); @Inject EdgeFactoryImpl(final DefinitionManager definitionManager); @Override Class<? extends ElementFactory> getFactoryType(); @Override @SuppressWarnings("unchecked") Edge<Definition<Object>, Node> build(final String uuid,
final Object definition); @Override boolean accepts(final Object source); }### Answer:
@Test public void testBuild() { final Edge<Definition<Object>, Node> edge = tested.build(UUID, definition); assertNotNull(edge); assertEquals(UUID, edge.getUUID()); assertEquals(3, edge.getLabels().size()); assertTrue(edge.getLabels().contains(ID)); assertTrue(edge.getLabels().contains("label1")); assertTrue(edge.getLabels().contains("label2")); } |
### Question:
GraphFactoryImpl extends AbstractGraphFactory { @Override public Class<? extends ElementFactory> getFactoryType() { return GraphFactory.class; } protected GraphFactoryImpl(); @Inject GraphFactoryImpl(final DefinitionManager definitionManager); @Override Class<? extends ElementFactory> getFactoryType(); @Override boolean accepts(final String source); }### Answer:
@Test public void testType() { assertEquals(GraphFactory.class, this.tested.getFactoryType()); } |
### Question:
DiagramFactoryImpl implements DiagramFactory<Metadata, Diagram<Graph, Metadata>> { @Override public Class<? extends Metadata> getMetadataType() { return Metadata.class; } @Override Class<? extends Metadata> getMetadataType(); @Override Diagram<Graph, Metadata> build(final String name,
final Metadata metadata,
final Graph<DefinitionSet, ?> graph); @Override boolean accepts(final String source); @Override boolean isDefault(); }### Answer:
@Test public void testType() { assertEquals(Metadata.class, this.tested.getMetadataType()); } |
### Question:
DiagramFactoryImpl implements DiagramFactory<Metadata, Diagram<Graph, Metadata>> { @Override public Diagram<Graph, Metadata> build(final String name, final Metadata metadata, final Graph<DefinitionSet, ?> graph) { final AbstractDiagram<Graph, Metadata> result = new DiagramImpl(name, metadata); result.setGraph(graph); return result; } @Override Class<? extends Metadata> getMetadataType(); @Override Diagram<Graph, Metadata> build(final String name,
final Metadata metadata,
final Graph<DefinitionSet, ?> graph); @Override boolean accepts(final String source); @Override boolean isDefault(); }### Answer:
@Test public void testBuild() { final Diagram<Graph, Metadata> diagram = tested.build(NAME, metadata, graph); assertNotNull(diagram); assertEquals(NAME, diagram.getName()); assertEquals(metadata, diagram.getMetadata()); assertEquals(graph, diagram.getGraph()); } |
### Question:
NodeFactoryImpl extends AbstractElementFactory<Object, Definition<Object>, Node<Definition<Object>, Edge>> implements NodeFactory<Object> { @Override public Class<? extends ElementFactory> getFactoryType() { return NodeFactory.class; } protected NodeFactoryImpl(); @Inject NodeFactoryImpl(final DefinitionUtils definitionUtils); @Override Class<? extends ElementFactory> getFactoryType(); @Override @SuppressWarnings("unchecked") Node<Definition<Object>, Edge> build(final String uuid,
final Object definition); @Override boolean accepts(final Object source); }### Answer:
@Test public void testType() { assertEquals(NodeFactory.class, this.tested.getFactoryType()); } |
### Question:
NodeFactoryImpl extends AbstractElementFactory<Object, Definition<Object>, Node<Definition<Object>, Edge>> implements NodeFactory<Object> { @Override @SuppressWarnings("unchecked") public Node<Definition<Object>, Edge> build(final String uuid, final Object definition) { final NodeImpl node = new NodeImpl<>(uuid); final Bounds bounds = definitionUtils.buildBounds(definition, 0d, 0d); View<Object> content = new ViewImpl<>(definition, bounds); node.setContent(content); appendLabels(node.getLabels(), definition); return node; } protected NodeFactoryImpl(); @Inject NodeFactoryImpl(final DefinitionUtils definitionUtils); @Override Class<? extends ElementFactory> getFactoryType(); @Override @SuppressWarnings("unchecked") Node<Definition<Object>, Edge> build(final String uuid,
final Object definition); @Override boolean accepts(final Object source); }### Answer:
@Test @SuppressWarnings("unchecked") public void testBuild() { when(testingkHelper.getDefinitionAdapter().getId(eq(definition))).thenReturn(DefinitionId.build(DEF_ID)); final Node<Definition<Object>, Edge> node = tested.build(UUID, definition); assertNotNull(node); assertEquals(UUID, node.getUUID()); assertEquals(3, node.getLabels().size()); assertTrue(node.getLabels().contains(DEF_ID)); assertTrue(node.getLabels().contains("label1")); assertTrue(node.getLabels().contains("label2")); }
@Test @SuppressWarnings("unchecked") public void testBuildDynamicDefinition() { when(testingkHelper.getDefinitionAdapter().getId(eq(definition))).thenReturn(DefinitionId.build(DEF_TYPE_ID, DEF_ID)); final Node<Definition<Object>, Edge> node = tested.build(UUID, definition); assertNotNull(node); assertEquals(UUID, node.getUUID()); assertEquals(4, node.getLabels().size()); assertTrue(node.getLabels().contains(DefinitionId.generateId(DEF_TYPE_ID, DEF_ID))); assertTrue(node.getLabels().contains(DEF_TYPE_ID)); assertTrue(node.getLabels().contains("label1")); assertTrue(node.getLabels().contains("label2")); } |
### Question:
RuleHandlerRegistryImpl implements RuleHandlerRegistry { @Override @SuppressWarnings("unchecked") public <T extends RuleExtensionHandler> T getExtensionHandler(final Class<T> contextType) { return (T) extensionHandlers.get(contextType); } @Override void register(final RuleEvaluationHandler handler); @Override Collection<RuleEvaluationHandler> getHandlersByContext(final Class<?> contextType); @Override @SuppressWarnings("unchecked") T getExtensionHandler(final Class<T> contextType); @Override void clear(); @Override boolean isEmpty(); @Override boolean remove(final RuleEvaluationHandler item); @Override boolean contains(final RuleEvaluationHandler item); }### Answer:
@Test @SuppressWarnings("unchecked") public void testGetExtension() { final RuleExtensionHandlerStub _extensionHandler = tested.getExtensionHandler(RuleExtensionHandlerStub.class); assertNotNull(_extensionHandler); assertEquals(extensionHandler, _extensionHandler); } |
### Question:
AbstractDynamicRegistryWrapper extends AbstractRegistryWrapper<T, R> implements DynamicRegistry<T> { @Override public void register(final T item) { getWrapped().register(item); } protected AbstractDynamicRegistryWrapper(final R wrapped); @Override void register(final T item); @Override boolean remove(final T item); }### Answer:
@Test @SuppressWarnings("unchecked") public void testRegister() { tested.register(s1); verify(registry, times(1)).register(eq(s1)); } |
### Question:
AbstractDynamicRegistryWrapper extends AbstractRegistryWrapper<T, R> implements DynamicRegistry<T> { @Override public boolean remove(final T item) { return getWrapped().remove(item); } protected AbstractDynamicRegistryWrapper(final R wrapped); @Override void register(final T item); @Override boolean remove(final T item); }### Answer:
@Test @SuppressWarnings("unchecked") public void testRemove() { tested.remove(s1); verify(registry, times(1)).remove(eq(s1)); } |
### Question:
AbstractRegistryWrapper implements Registry<T> { @Override public boolean contains(final T item) { return wrapped.contains(item); } protected AbstractRegistryWrapper(final R wrapped); @Override boolean contains(final T item); @Override boolean isEmpty(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testContains() { assertTrue(tested.contains(s1)); assertTrue(tested.contains(s2)); assertFalse(tested.contains("")); } |
### Question:
AbstractRegistryWrapper implements Registry<T> { @Override public boolean isEmpty() { return wrapped.isEmpty(); } protected AbstractRegistryWrapper(final R wrapped); @Override boolean contains(final T item); @Override boolean isEmpty(); }### Answer:
@Test public void testEmpty() { when(registry.isEmpty()).thenReturn(true); boolean empty = tested.isEmpty(); assertTrue(empty); }
@Test public void testNotEmpty() { boolean empty = registry.isEmpty(); assertFalse(empty); } |
### Question:
FactoryRegistryImpl implements TypeFactoryRegistry<T> { @Override public DefinitionFactory<?> getDefinitionFactory(final String id) { for (final DefinitionFactory<?> factory : definitionFactories) { if (factory.accepts(id)) { return factory; } } return null; } FactoryRegistryImpl(final AdapterManager adapterManager); @Override DefinitionFactory<?> getDefinitionFactory(final String id); @Override ElementFactory<?, ?, ?> getElementFactory(final Class<? extends ElementFactory> type); @Override @SuppressWarnings("unchecked") DiagramFactory<?, ?> getDiagramFactory(final String defSetId,
final Class<? extends Metadata> metadataType); @Override @SuppressWarnings("unchecked") void register(final T item); @Override boolean remove(final T item); @Override void clear(); @Override boolean contains(final T item); @Override boolean isEmpty(); @Override @SuppressWarnings("unchecked") Collection<T> getAllFactories(); @Override DefinitionFactory<?> getDefinitionFactory(final Class<?> type); }### Answer:
@Test public void testGetDefinitionFactory() { assertNull(tested.getDefinitionFactory(DefinitionFactory.class.getName())); tested.register(definitionFactory); assertNull(tested.getDefinitionFactory(NOT_VALID_ID)); assertEquals(definitionFactory, tested.getDefinitionFactory(DefinitionFactory.class.getName())); assertEquals(definitionFactory, tested.getDefinitionFactory(DefinitionFactory.class)); } |
### Question:
FactoryRegistryImpl implements TypeFactoryRegistry<T> { @Override public boolean contains(final T item) { if (item instanceof DefinitionFactory) { return definitionFactories.contains(item); } else if (item instanceof ElementFactory) { return graphFactories.containsValue(item); } else if (item instanceof DiagramFactory) { return diagramFactories.contains(item); } return false; } FactoryRegistryImpl(final AdapterManager adapterManager); @Override DefinitionFactory<?> getDefinitionFactory(final String id); @Override ElementFactory<?, ?, ?> getElementFactory(final Class<? extends ElementFactory> type); @Override @SuppressWarnings("unchecked") DiagramFactory<?, ?> getDiagramFactory(final String defSetId,
final Class<? extends Metadata> metadataType); @Override @SuppressWarnings("unchecked") void register(final T item); @Override boolean remove(final T item); @Override void clear(); @Override boolean contains(final T item); @Override boolean isEmpty(); @Override @SuppressWarnings("unchecked") Collection<T> getAllFactories(); @Override DefinitionFactory<?> getDefinitionFactory(final Class<?> type); }### Answer:
@Test public void testContains() { assertFalse(tested.contains(elementFactory)); assertFalse(tested.contains(definitionFactory)); assertFalse(tested.contains(null)); tested.register(elementFactory); tested.register(definitionFactory); assertTrue(tested.contains(elementFactory)); assertTrue(tested.contains(definitionFactory)); assertFalse(tested.contains(missingFactory)); assertFalse(tested.contains(null)); } |
### Question:
FactoryRegistryImpl implements TypeFactoryRegistry<T> { @Override public void clear() { definitionFactories.clear(); graphFactories.clear(); diagramFactories.clear(); } FactoryRegistryImpl(final AdapterManager adapterManager); @Override DefinitionFactory<?> getDefinitionFactory(final String id); @Override ElementFactory<?, ?, ?> getElementFactory(final Class<? extends ElementFactory> type); @Override @SuppressWarnings("unchecked") DiagramFactory<?, ?> getDiagramFactory(final String defSetId,
final Class<? extends Metadata> metadataType); @Override @SuppressWarnings("unchecked") void register(final T item); @Override boolean remove(final T item); @Override void clear(); @Override boolean contains(final T item); @Override boolean isEmpty(); @Override @SuppressWarnings("unchecked") Collection<T> getAllFactories(); @Override DefinitionFactory<?> getDefinitionFactory(final Class<?> type); }### Answer:
@Test public void testClear() { tested.register(elementFactory); tested.register(definitionFactory); tested.register(missingFactory); tested.clear(); assertArrayEquals(new Object[0], tested.getAllFactories().toArray()); } |
### Question:
FactoryRegistryImpl implements TypeFactoryRegistry<T> { @Override public boolean isEmpty() { return definitionFactories.isEmpty() && graphFactories.isEmpty(); } FactoryRegistryImpl(final AdapterManager adapterManager); @Override DefinitionFactory<?> getDefinitionFactory(final String id); @Override ElementFactory<?, ?, ?> getElementFactory(final Class<? extends ElementFactory> type); @Override @SuppressWarnings("unchecked") DiagramFactory<?, ?> getDiagramFactory(final String defSetId,
final Class<? extends Metadata> metadataType); @Override @SuppressWarnings("unchecked") void register(final T item); @Override boolean remove(final T item); @Override void clear(); @Override boolean contains(final T item); @Override boolean isEmpty(); @Override @SuppressWarnings("unchecked") Collection<T> getAllFactories(); @Override DefinitionFactory<?> getDefinitionFactory(final Class<?> type); }### Answer:
@Test public void testEmpty() { boolean empty = tested.isEmpty(); assertTrue(empty); } |
### Question:
FactoryRegistryImpl implements TypeFactoryRegistry<T> { @Override public boolean remove(final T item) { if (item instanceof DefinitionFactory) { return definitionFactories.remove(item); } else if (item instanceof ElementFactory) { return null != graphFactories.remove(((ElementFactory) item).getFactoryType()); } else if (item instanceof DiagramFactory) { return diagramFactories.remove(item); } return false; } FactoryRegistryImpl(final AdapterManager adapterManager); @Override DefinitionFactory<?> getDefinitionFactory(final String id); @Override ElementFactory<?, ?, ?> getElementFactory(final Class<? extends ElementFactory> type); @Override @SuppressWarnings("unchecked") DiagramFactory<?, ?> getDiagramFactory(final String defSetId,
final Class<? extends Metadata> metadataType); @Override @SuppressWarnings("unchecked") void register(final T item); @Override boolean remove(final T item); @Override void clear(); @Override boolean contains(final T item); @Override boolean isEmpty(); @Override @SuppressWarnings("unchecked") Collection<T> getAllFactories(); @Override DefinitionFactory<?> getDefinitionFactory(final Class<?> type); }### Answer:
@Test public void testRemove() { tested.register(elementFactory); tested.register(definitionFactory); assertFalse(tested.remove(missingFactory)); assertTrue(tested.contains(elementFactory)); assertTrue(tested.contains(definitionFactory)); assertTrue(tested.remove(elementFactory)); assertFalse(tested.contains(elementFactory)); assertTrue(tested.contains(definitionFactory)); assertFalse(tested.remove(null)); assertTrue(tested.contains(definitionFactory)); assertTrue(tested.remove(definitionFactory)); assertFalse(tested.contains(definitionFactory)); assertArrayEquals(new Object[0], tested.getAllFactories().toArray()); } |
### Question:
FactoryRegistryImpl implements TypeFactoryRegistry<T> { @Override @SuppressWarnings("unchecked") public void register(final T item) { if (item instanceof DefinitionFactory) { definitionFactories.add((DefinitionFactory<?>) item); } else if (item instanceof ElementFactory) { registerGraphFactory((ElementFactory) item); } else if (item instanceof DiagramFactory) { diagramFactories.add((DiagramFactory<?, ?>) item); } } FactoryRegistryImpl(final AdapterManager adapterManager); @Override DefinitionFactory<?> getDefinitionFactory(final String id); @Override ElementFactory<?, ?, ?> getElementFactory(final Class<? extends ElementFactory> type); @Override @SuppressWarnings("unchecked") DiagramFactory<?, ?> getDiagramFactory(final String defSetId,
final Class<? extends Metadata> metadataType); @Override @SuppressWarnings("unchecked") void register(final T item); @Override boolean remove(final T item); @Override void clear(); @Override boolean contains(final T item); @Override boolean isEmpty(); @Override @SuppressWarnings("unchecked") Collection<T> getAllFactories(); @Override DefinitionFactory<?> getDefinitionFactory(final Class<?> type); }### Answer:
@Test public void testRegister() { DefinitionFactory definitionFactory = mock(DefinitionFactory.class); ElementFactory graphFactory = mock(ElementFactory.class); DiagramFactory diagramFactory = mock(DiagramFactory.class); Factory randomFactory = mock(Factory.class); FactoryRegistryImpl factory = new FactoryRegistryImpl(adapter); factory.register(definitionFactory); factory.register(graphFactory); factory.register(diagramFactory); factory.register(randomFactory); Collection<?> factories = factory.getAllFactories(); assertEquals(3, factories.stream().count()); } |
### Question:
FactoryRegistryImpl implements TypeFactoryRegistry<T> { protected void registerGraphFactory(final ElementFactory item) { final Class<? extends ElementFactory> factoryType = item.getFactoryType(); if (!graphFactories.containsKey(item.getFactoryType()) || item.isDelegateFactory()) { graphFactories.put(factoryType, item); } } FactoryRegistryImpl(final AdapterManager adapterManager); @Override DefinitionFactory<?> getDefinitionFactory(final String id); @Override ElementFactory<?, ?, ?> getElementFactory(final Class<? extends ElementFactory> type); @Override @SuppressWarnings("unchecked") DiagramFactory<?, ?> getDiagramFactory(final String defSetId,
final Class<? extends Metadata> metadataType); @Override @SuppressWarnings("unchecked") void register(final T item); @Override boolean remove(final T item); @Override void clear(); @Override boolean contains(final T item); @Override boolean isEmpty(); @Override @SuppressWarnings("unchecked") Collection<T> getAllFactories(); @Override DefinitionFactory<?> getDefinitionFactory(final Class<?> type); }### Answer:
@Test public void testRegisterGraphFactory() { Class<? extends ElementFactory> factoryType = GraphFactory.class; ElementFactory graphFactory1 = createGraphFactory(factoryType); ElementFactory graphFactory2 = createGraphFactory(factoryType); ElementFactory delegateGraphFactory = createDelegateGraphFactory(factoryType); FactoryRegistryImpl factory = new FactoryRegistryImpl(adapter); factory.register(null); assertTrue(factory.getAllFactories().isEmpty()); factory.registerGraphFactory(graphFactory1); assertEquals(graphFactory1, factory.getElementFactory(factoryType)); factory.clear(); factory.registerGraphFactory(delegateGraphFactory); assertEquals(delegateGraphFactory, factory.getElementFactory(factoryType)); factory.clear(); factory.registerGraphFactory(graphFactory1); factory.registerGraphFactory(graphFactory2); assertEquals(graphFactory1, factory.getElementFactory(factoryType)); factory.registerGraphFactory(graphFactory1); factory.registerGraphFactory(delegateGraphFactory); assertEquals(delegateGraphFactory, factory.getElementFactory(factoryType)); } |
### Question:
ListRegistry implements DynamicRegistry<T> { @Override public void register(final T item) { items.add(item); } ListRegistry(final KeyProvider<T> keyProvider,
final List<T> items); void add(final int pos,
final T item); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); Collection<T> getItems(); T getItemByKey(final String id); void clear(); int indexOf(final T item); }### Answer:
@Test public void testRegister() { final String s = "an string"; tested.register(s); verify(list, times(1)).add(s); } |
### Question:
ListRegistry implements DynamicRegistry<T> { public void add(final int pos, final T item) { items.add(pos, item); } ListRegistry(final KeyProvider<T> keyProvider,
final List<T> items); void add(final int pos,
final T item); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); Collection<T> getItems(); T getItemByKey(final String id); void clear(); int indexOf(final T item); }### Answer:
@Test public void testAdd() { final String s = "an string"; tested.add(1, s); verify(list, times(1)).add(1, s); } |
### Question:
ListRegistry implements DynamicRegistry<T> { public boolean remove(final T item) { return items.remove(item); } ListRegistry(final KeyProvider<T> keyProvider,
final List<T> items); void add(final int pos,
final T item); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); Collection<T> getItems(); T getItemByKey(final String id); void clear(); int indexOf(final T item); }### Answer:
@Test public void testRemove() { final String s = "an string"; tested.remove(s); verify(list, times(1)).remove(s); } |
### Question:
ListRegistry implements DynamicRegistry<T> { @Override public boolean contains(final T item) { return items.contains(item); } ListRegistry(final KeyProvider<T> keyProvider,
final List<T> items); void add(final int pos,
final T item); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); Collection<T> getItems(); T getItemByKey(final String id); void clear(); int indexOf(final T item); }### Answer:
@Test public void testContains() { final String s = "an string"; tested.contains(s); verify(list, times(1)).contains(s); } |
### Question:
ListRegistry implements DynamicRegistry<T> { @Override public boolean isEmpty() { return items.isEmpty(); } ListRegistry(final KeyProvider<T> keyProvider,
final List<T> items); void add(final int pos,
final T item); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); Collection<T> getItems(); T getItemByKey(final String id); void clear(); int indexOf(final T item); }### Answer:
@Test public void testEmpty() { when(list.isEmpty()).thenReturn(true); boolean empty = tested.isEmpty(); assertTrue(empty); }
@Test public void testNotEmpty() { when(list.isEmpty()).thenReturn(false); boolean empty = tested.isEmpty(); assertFalse(empty); } |
### Question:
ListRegistry implements DynamicRegistry<T> { public void clear() { items.clear(); } ListRegistry(final KeyProvider<T> keyProvider,
final List<T> items); void add(final int pos,
final T item); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); Collection<T> getItems(); T getItemByKey(final String id); void clear(); int indexOf(final T item); }### Answer:
@Test public void testClear() { tested.clear(); verify(list, times(1)).clear(); } |
### Question:
ListRegistry implements DynamicRegistry<T> { public int indexOf(final T item) { return items.indexOf(item); } ListRegistry(final KeyProvider<T> keyProvider,
final List<T> items); void add(final int pos,
final T item); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); Collection<T> getItems(); T getItemByKey(final String id); void clear(); int indexOf(final T item); }### Answer:
@Test public void testIndexOf() { final String s = "an string"; tested.indexOf(s); verify(list, times(1)).indexOf(s); } |
### Question:
ListRegistry implements DynamicRegistry<T> { public Collection<T> getItems() { return Collections.unmodifiableList(items); } ListRegistry(final KeyProvider<T> keyProvider,
final List<T> items); void add(final int pos,
final T item); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); Collection<T> getItems(); T getItemByKey(final String id); void clear(); int indexOf(final T item); }### Answer:
@Test public void testGetItems() { final String s1 = "an string 1"; final String s2 = "an string 2"; tested = new ListRegistry<>(keyProvider, new ArrayList<Object>(2) {{ add(s1); add(s2); }}); Collection<Object> items = tested.getItems(); assertNotNull(items); assertEquals(2, items.size()); Iterator<Object> it = items.iterator(); assertEquals(s1, it.next()); assertEquals(s2, it.next()); } |
### Question:
ListRegistry implements DynamicRegistry<T> { public T getItemByKey(final String id) { if (null != id) { for (final T item : items) { final String itemId = getItemKey(item); if (id.equals(itemId)) { return item; } } } return null; } ListRegistry(final KeyProvider<T> keyProvider,
final List<T> items); void add(final int pos,
final T item); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); Collection<T> getItems(); T getItemByKey(final String id); void clear(); int indexOf(final T item); }### Answer:
@Test public void testGetItemByKey() { final String s1 = "an string 1"; final String s2 = "an string 2"; tested = new ListRegistry<>(keyProvider, new ArrayList<Object>(2) {{ add(s1); add(s2); }}); Object o1 = tested.getItemByKey(s1); Object o2 = tested.getItemByKey(s2); assertEquals(s1, o1); assertEquals(s2, o2); assertEquals(null, tested.getItemByKey(null)); assertEquals(null, tested.getItemByKey("unregistered string")); } |
### Question:
StackRegistry implements DynamicRegistry<T> { @Override public void register(final T item) { items.add(item); } StackRegistry(final KeyProvider<T> keyProvider,
final Stack<T> items); T peek(); T pop(); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); T getItemByKey(final String id); int indexOf(final T item); }### Answer:
@Test public void testRegister() { final String s = "an string"; tested.register(s); verify(stack, times(1)).add(s); } |
### Question:
StackRegistry implements DynamicRegistry<T> { Stack<T> getStack() { return items; } StackRegistry(final KeyProvider<T> keyProvider,
final Stack<T> items); T peek(); T pop(); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); T getItemByKey(final String id); int indexOf(final T item); }### Answer:
@Test public void testGetStack() { assertEquals(stack, tested.getStack()); } |
### Question:
StackRegistry implements DynamicRegistry<T> { public T peek() { return items.peek(); } StackRegistry(final KeyProvider<T> keyProvider,
final Stack<T> items); T peek(); T pop(); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); T getItemByKey(final String id); int indexOf(final T item); }### Answer:
@Test public void testPeek() { tested.peek(); verify(stack, times(1)).peek(); } |
### Question:
StackRegistry implements DynamicRegistry<T> { public T pop() { return items.pop(); } StackRegistry(final KeyProvider<T> keyProvider,
final Stack<T> items); T peek(); T pop(); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); T getItemByKey(final String id); int indexOf(final T item); }### Answer:
@Test public void testPop() { tested.pop(); verify(stack, times(1)).pop(); } |
### Question:
StackRegistry implements DynamicRegistry<T> { public boolean remove(final T item) { return items.remove(item); } StackRegistry(final KeyProvider<T> keyProvider,
final Stack<T> items); T peek(); T pop(); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); T getItemByKey(final String id); int indexOf(final T item); }### Answer:
@Test public void testRemove() { final String s = "an string"; tested.remove(s); verify(stack, times(1)).remove(s); } |
### Question:
StackRegistry implements DynamicRegistry<T> { @Override public boolean contains(final T item) { return items.contains(item); } StackRegistry(final KeyProvider<T> keyProvider,
final Stack<T> items); T peek(); T pop(); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); T getItemByKey(final String id); int indexOf(final T item); }### Answer:
@Test public void testContains() { final String s = "an string"; tested.contains(s); verify(stack, times(1)).contains(s); } |
### Question:
StackRegistry implements DynamicRegistry<T> { public int indexOf(final T item) { return items.indexOf(item); } StackRegistry(final KeyProvider<T> keyProvider,
final Stack<T> items); T peek(); T pop(); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); T getItemByKey(final String id); int indexOf(final T item); }### Answer:
@Test public void testIndexOf() { final String s = "an string"; tested.indexOf(s); verify(stack, times(1)).indexOf(s); } |
### Question:
StackRegistry implements DynamicRegistry<T> { public T getItemByKey(final String id) { if (null != id) { for (final T item : items) { final String itemId = getItemKey(item); if (id.equals(itemId)) { return item; } } } return null; } StackRegistry(final KeyProvider<T> keyProvider,
final Stack<T> items); T peek(); T pop(); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); T getItemByKey(final String id); int indexOf(final T item); }### Answer:
@Test public void testGetItemByKey() { final String s1 = "an string 1"; final String s2 = "an string 2"; tested = new StackRegistry<>(keyProvider, new Stack<Object>() {{ push(s1); push(s2); }}); Object o1 = tested.getItemByKey(s1); Object o2 = tested.getItemByKey(s2); assertEquals(s1, o1); assertEquals(s2, o2); assertEquals(null, tested.getItemByKey(null)); assertEquals(null, tested.getItemByKey("unregistered string")); } |
### Question:
StackRegistry implements DynamicRegistry<T> { @Override public boolean isEmpty() { return items.isEmpty(); } StackRegistry(final KeyProvider<T> keyProvider,
final Stack<T> items); T peek(); T pop(); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); T getItemByKey(final String id); int indexOf(final T item); }### Answer:
@Test public void testEmpty() { when(stack.isEmpty()).thenReturn(true); boolean empty = tested.isEmpty(); assertTrue(empty); }
@Test public void testNotEmpty() { when(stack.isEmpty()).thenReturn(false); boolean empty = tested.isEmpty(); assertFalse(empty); } |
### Question:
MapRegistry implements DynamicRegistry<T> { @Override public void register(final T item) { items.put(getItemId(item), item); } MapRegistry(final KeyProvider<T> keyProvider,
final Map<String, T> items); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); Collection<T> getItems(); void clear(); T getItemByKey(final String key); }### Answer:
@Test public void testRegister() { final String s = "an string"; tested.register(s); verify(map, times(1)).put(s, s); } |
### Question:
MapRegistry implements DynamicRegistry<T> { public boolean remove(final T item) { return null != items.remove(getItemId(item)); } MapRegistry(final KeyProvider<T> keyProvider,
final Map<String, T> items); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); Collection<T> getItems(); void clear(); T getItemByKey(final String key); }### Answer:
@Test public void testRemove() { final String s = "an string"; tested.remove(s); verify(map, times(1)).remove(s); } |
### Question:
MapRegistry implements DynamicRegistry<T> { @Override public boolean contains(final T item) { return items.containsValue(item); } MapRegistry(final KeyProvider<T> keyProvider,
final Map<String, T> items); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); Collection<T> getItems(); void clear(); T getItemByKey(final String key); }### Answer:
@Test public void testContains() { final String s = "an string"; tested.contains(s); verify(map, times(1)).containsValue(s); } |
### Question:
MapRegistry implements DynamicRegistry<T> { public void clear() { items.clear(); } MapRegistry(final KeyProvider<T> keyProvider,
final Map<String, T> items); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); Collection<T> getItems(); void clear(); T getItemByKey(final String key); }### Answer:
@Test public void testClear() { tested.clear(); verify(map, times(1)).clear(); } |
### Question:
MapRegistry implements DynamicRegistry<T> { public Collection<T> getItems() { return Collections.unmodifiableList(new ArrayList<T>(items.values())); } MapRegistry(final KeyProvider<T> keyProvider,
final Map<String, T> items); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); Collection<T> getItems(); void clear(); T getItemByKey(final String key); }### Answer:
@Test public void testGetItems() { final String s1 = "an string 1"; final String s2 = "an string 2"; tested = new MapRegistry<Object>(keyProvider, new HashMap<String, Object>(2) {{ put(s1, s1); put(s2, s2); }}); Collection<Object> items = tested.getItems(); assertNotNull(items); assertEquals(2, items.size()); Iterator<Object> it = items.iterator(); assertEquals(s1, it.next()); assertEquals(s2, it.next()); } |
### Question:
MapRegistry implements DynamicRegistry<T> { public T getItemByKey(final String key) { return items.get(key); } MapRegistry(final KeyProvider<T> keyProvider,
final Map<String, T> items); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); Collection<T> getItems(); void clear(); T getItemByKey(final String key); }### Answer:
@Test public void testGetItemByKey() { final String s1 = "an string 1"; final String s2 = "an string 2"; tested = new MapRegistry<Object>(keyProvider, new HashMap<String, Object>(2) {{ put(s1, s1); put(s2, s2); }}); Object o1 = tested.getItemByKey(s1); Object o2 = tested.getItemByKey(s2); assertEquals(s1, o1); assertEquals(s2, o2); } |
### Question:
MapRegistry implements DynamicRegistry<T> { @Override public boolean isEmpty() { return items.isEmpty(); } MapRegistry(final KeyProvider<T> keyProvider,
final Map<String, T> items); @Override void register(final T item); boolean remove(final T item); @Override boolean contains(final T item); @Override boolean isEmpty(); Collection<T> getItems(); void clear(); T getItemByKey(final String key); }### Answer:
@Test public void testEmpty() { when(map.isEmpty()).thenReturn(true); boolean empty = tested.isEmpty(); assertTrue(empty); }
@Test public void testNotEmpty() { when(map.isEmpty()).thenReturn(false); boolean empty = tested.isEmpty(); assertFalse(empty); } |
### Question:
DiagramImpl extends AbstractDiagram<Graph, Metadata> { @Override public int hashCode() { int graphHash = (null != getGraph()) ? getGraph().hashCode() : 0; int metadataHash = (null != getMetadata()) ? getMetadata().hashCode() : 0; int nameHash = (null != getName()) ? getName().hashCode() : 0; return HashUtil.combineHashCodes(graphHash, metadataHash, nameHash); } DiagramImpl(final @MapsTo("name") String name,
final @MapsTo("metadata") Metadata metadata); DiagramImpl(final String name,
final Graph graph,
final Metadata metadata); @Override int hashCode(); @Override boolean equals(Object o); }### Answer:
@Test public void testDiagramHashCode() { DiagramImpl a = new DiagramImpl("Diagram", new MetadataImpl()); DiagramImpl b = new DiagramImpl("AnotherDiagram", new MetadataImpl()); assertNotEquals(a.hashCode(), b.hashCode()); b = new DiagramImpl("Diagram", new MetadataImpl()); assertEquals(a.hashCode(), b.hashCode()); a.setGraph(new GraphImpl("Graph", new GraphNodeStoreImpl())); b.setGraph(new GraphImpl("Graph", new GraphNodeStoreImpl())); assertEquals(a.hashCode(), b.hashCode()); a.getGraph().addNode(new NodeImpl("Node1")); b.getGraph().addNode(new NodeImpl("Node2")); assertNotEquals(a.hashCode(), b.hashCode()); b.getGraph().removeNode("Node2"); b.getGraph().addNode(new NodeImpl("Node1")); assertEquals(a.hashCode(), b.hashCode()); assertEquals(a.hashCode(), a.hashCode()); } |
### Question:
CachedRuleManager implements RuleManager { @Override public RuleViolations evaluate(final RuleSet ruleSet, final RuleEvaluationContext context) { return ruleManager.evaluate(ruleSet, context); } @Inject CachedRuleManager(final RuleManagerImpl ruleManager); @PostConstruct void init(); @Override RuleHandlerRegistry registry(); @Override RuleViolations evaluate(final RuleSet ruleSet,
final RuleEvaluationContext context); @PreDestroy void destroy(); }### Answer:
@Test public void testEvaluateContainmentContextOnce() { tested.evaluate(ruleSet, containmentContext); tested.evaluate(ruleSet, containmentContext); verify(ruleSet, times(1)).getRules(); verify(containmentHandler, times(2)).evaluate(eq(containmentRule), eq(containmentContext)); verify(connectionHandler, never()).evaluate(any(CanConnect.class), any(ConnectionContext.class)); }
@Test public void testEvaluateConnectionContextOnce() { tested.evaluate(ruleSet, connectionContext); tested.evaluate(ruleSet, connectionContext); verify(ruleSet, times(1)).getRules(); verify(connectionHandler, times(2)).evaluate(eq(connectionRule), eq(connectionContext)); verify(containmentHandler, never()).evaluate(any(CanContain.class), any(ContainmentContext.class)); } |
### Question:
RuleExtensionMultiHandler extends RuleExtensionHandler<RuleExtensionHandler, RuleEvaluationContext> { @Override @SuppressWarnings("unchecked") public boolean accepts(final RuleExtension rule, final RuleEvaluationContext context) { return handlers.stream().anyMatch(h -> isHandlerAccepted(h, rule, context)); } boolean addHandler(final RuleExtensionHandler handler); @Override Class<RuleExtensionHandler> getExtensionType(); @Override Class<RuleEvaluationContext> getContextType(); @Override @SuppressWarnings("unchecked") boolean accepts(final RuleExtension rule,
final RuleEvaluationContext context); @Override @SuppressWarnings("unchecked") RuleViolations evaluate(final RuleExtension rule,
final RuleEvaluationContext context); }### Answer:
@Test @SuppressWarnings("unchecked") public void testAcceptAll() { when(handler1.accepts(eq(rule1), eq(context))).thenReturn(true); when(handler2.accepts(eq(rule1), eq(context))).thenReturn(true); final boolean accepts = tested.accepts(rule1, context); assertTrue(accepts); }
@Test @SuppressWarnings("unchecked") public void testAcceptAllBut1() { when(handler1.accepts(eq(rule1), eq(context))).thenReturn(true); when(handler2.accepts(eq(rule1), eq(context))).thenReturn(false); final boolean accepts = tested.accepts(rule1, context); assertTrue(accepts); }
@Test @SuppressWarnings("unchecked") public void testAcceptAllBut2() { when(handler1.accepts(eq(rule1), eq(context))).thenReturn(false); when(handler2.accepts(eq(rule1), eq(context))).thenReturn(true); final boolean accepts = tested.accepts(rule1, context); assertTrue(accepts); }
@Test @SuppressWarnings("unchecked") public void testNotAccept() { when(handler1.accepts(eq(rule1), eq(context))).thenReturn(false); when(handler2.accepts(eq(rule1), eq(context))).thenReturn(false); final boolean accepts = tested.accepts(rule1, context); assertFalse(accepts); } |
### Question:
ConnectorParentsMatchHandler extends RuleExtensionHandler<ConnectorParentsMatchHandler, RuleEvaluationContext> { @PostConstruct public void init() { multiHandler.addHandler(connectionHandler); multiHandler.addHandler(containmentHandler); } protected ConnectorParentsMatchHandler(); @Inject ConnectorParentsMatchHandler(final ConnectorParentsMatchConnectionHandler connectionHandler,
final ConnectorParentsMatchContainmentHandler containmentHandler,
final RuleExtensionMultiHandler multiHandler); @PostConstruct void init(); @Override Class<ConnectorParentsMatchHandler> getExtensionType(); @Override Class<RuleEvaluationContext> getContextType(); @Override boolean accepts(final RuleExtension rule,
final RuleEvaluationContext context); @Override RuleViolations evaluate(final RuleExtension rule,
final RuleEvaluationContext context); }### Answer:
@Test public void testInit() { tested.init(); verify(multiHandler, times(1)).addHandler(eq(connectionHandler)); verify(multiHandler, times(1)).addHandler(eq(containmentHandler)); } |
### Question:
ConnectorParentsMatchHandler extends RuleExtensionHandler<ConnectorParentsMatchHandler, RuleEvaluationContext> { @Override public boolean accepts(final RuleExtension rule, final RuleEvaluationContext context) { return multiHandler.accepts(rule, context); } protected ConnectorParentsMatchHandler(); @Inject ConnectorParentsMatchHandler(final ConnectorParentsMatchConnectionHandler connectionHandler,
final ConnectorParentsMatchContainmentHandler containmentHandler,
final RuleExtensionMultiHandler multiHandler); @PostConstruct void init(); @Override Class<ConnectorParentsMatchHandler> getExtensionType(); @Override Class<RuleEvaluationContext> getContextType(); @Override boolean accepts(final RuleExtension rule,
final RuleEvaluationContext context); @Override RuleViolations evaluate(final RuleExtension rule,
final RuleEvaluationContext context); }### Answer:
@Test public void testAccept() { final RuleExtension ruleExtension = mock(RuleExtension.class); when(ruleExtension.getArguments()).thenReturn(new String[]{"parentType"}); final RuleEvaluationContext context = mock(RuleEvaluationContext.class); assertTrue(tested.accepts(ruleExtension, context)); verify(multiHandler, times(1)).accepts(eq(ruleExtension), eq(context)); } |
### Question:
ConnectorParentsMatchHandler extends RuleExtensionHandler<ConnectorParentsMatchHandler, RuleEvaluationContext> { @Override public RuleViolations evaluate(final RuleExtension rule, final RuleEvaluationContext context) { return multiHandler.evaluate(rule, context); } protected ConnectorParentsMatchHandler(); @Inject ConnectorParentsMatchHandler(final ConnectorParentsMatchConnectionHandler connectionHandler,
final ConnectorParentsMatchContainmentHandler containmentHandler,
final RuleExtensionMultiHandler multiHandler); @PostConstruct void init(); @Override Class<ConnectorParentsMatchHandler> getExtensionType(); @Override Class<RuleEvaluationContext> getContextType(); @Override boolean accepts(final RuleExtension rule,
final RuleEvaluationContext context); @Override RuleViolations evaluate(final RuleExtension rule,
final RuleEvaluationContext context); }### Answer:
@Test public void testEvaluate() { final RuleExtension ruleExtension = mock(RuleExtension.class); when(ruleExtension.getArguments()).thenReturn(new String[]{"parentType"}); final RuleEvaluationContext context = mock(RuleEvaluationContext.class); assertEquals(ruleViolations, tested.evaluate(ruleExtension, context)); verify(multiHandler, times(1)).evaluate(eq(ruleExtension), eq(context)); } |
### Question:
ConnectorParentsMatchContainmentHandler extends AbstractParentsMatchHandler<ConnectorParentsMatchContainmentHandler, NodeContainmentContext> { @Override @SuppressWarnings("unchecked") public boolean accepts(final RuleExtension rule, final NodeContainmentContext context) { final Collection<Node<? extends Definition<?>, ? extends Edge>> candidates = context.getCandidates(); return candidates.stream() .anyMatch(node -> hasAnyEdgeOfInterest(node, rule.getId())); } protected ConnectorParentsMatchContainmentHandler(); @Inject ConnectorParentsMatchContainmentHandler(final DefinitionManager definitionManager,
final TreeWalkTraverseProcessor treeWalkTraverseProcessor); @Override Class<ConnectorParentsMatchContainmentHandler> getExtensionType(); @Override Class<NodeContainmentContext> getContextType(); @Override @SuppressWarnings("unchecked") boolean accepts(final RuleExtension rule,
final NodeContainmentContext context); @Override RuleViolations evaluate(final RuleExtension rule,
final NodeContainmentContext context); }### Answer:
@Test @SuppressWarnings("unchecked") public void testAccepts() { when(ruleExtension.getTypeArguments()).thenReturn(new Class[]{ParentDefinition.class}); when(containmentContext.getCandidates()).thenReturn(candidates); when(containmentContext.getParent()).thenReturn(parentNode); graphHandler.addEdge(connector, nodeA) .connectTo(connector, nodeB); assertTrue(tested.accepts(ruleExtension, containmentContext)); }
@Test @SuppressWarnings("unchecked") public void testNotAccepts() { when(ruleExtension.getTypeArguments()).thenReturn(new Class[]{DefinitionC.class}); when(containmentContext.getCandidates()).thenReturn(candidates); when(containmentContext.getParent()).thenReturn(parentNode); assertFalse(tested.accepts(ruleExtension, containmentContext)); } |
### Question:
ConnectorParentsMatchContainmentHandler extends AbstractParentsMatchHandler<ConnectorParentsMatchContainmentHandler, NodeContainmentContext> { @Override public RuleViolations evaluate(final RuleExtension rule, final NodeContainmentContext context) { return evaluateContainment(rule, context); } protected ConnectorParentsMatchContainmentHandler(); @Inject ConnectorParentsMatchContainmentHandler(final DefinitionManager definitionManager,
final TreeWalkTraverseProcessor treeWalkTraverseProcessor); @Override Class<ConnectorParentsMatchContainmentHandler> getExtensionType(); @Override Class<NodeContainmentContext> getContextType(); @Override @SuppressWarnings("unchecked") boolean accepts(final RuleExtension rule,
final NodeContainmentContext context); @Override RuleViolations evaluate(final RuleExtension rule,
final NodeContainmentContext context); }### Answer:
@Test @SuppressWarnings("unchecked") public void testEvaluateParentSuccess() { when(ruleExtension.getTypeArguments()).thenReturn(new Class[]{ParentDefinition.class}); when(containmentContext.getCandidates()).thenReturn(candidates); when(containmentContext.getParent()).thenReturn(parentNode); graphHandler.addEdge(connector, nodeA) .connectTo(connector, nodeB); final RuleViolations violations = tested.evaluate(ruleExtension, containmentContext); assertNotNull(violations); assertViolations(violations, true); }
@Test @SuppressWarnings("unchecked") public void testEvaluateParentFailed() { when(ruleExtension.getTypeArguments()).thenReturn(new Class[]{ParentDefinition.class}); when(containmentContext.getCandidates()).thenReturn(candidates); when(containmentContext.getParent()).thenReturn(parentNode); graphHandler.addEdge(connector, nodeA) .connectTo(connector, nodeC); final RuleViolations violations = tested.evaluate(ruleExtension, containmentContext); assertNotNull(violations); assertViolations(violations, false); } |
### Question:
ConnectorParentsMatchConnectionHandler extends AbstractParentsMatchHandler<ConnectorParentsMatchConnectionHandler, GraphConnectionContext> { @Override public boolean accepts(final RuleExtension rule, final GraphConnectionContext context) { return acceptsConnection(rule, context); } protected ConnectorParentsMatchConnectionHandler(); @Inject ConnectorParentsMatchConnectionHandler(final DefinitionManager definitionManager); @Override Class<ConnectorParentsMatchConnectionHandler> getExtensionType(); @Override Class<GraphConnectionContext> getContextType(); @Override boolean accepts(final RuleExtension rule,
final GraphConnectionContext context); @Override RuleViolations evaluate(final RuleExtension rule,
final GraphConnectionContext context); }### Answer:
@Test @SuppressWarnings("unchecked") public void testAccepts() { when(connectionContext.getSource()).thenReturn(Optional.of(nodeA)); when(connectionContext.getTarget()).thenReturn(Optional.of(nodeB)); when(ruleExtension.getTypeArguments()).thenReturn(new Class[]{ParentDefinition.class}); assertTrue(tested.accepts(ruleExtension, connectionContext)); }
@Test @SuppressWarnings("unchecked") public void testNotAccepts() { when(connectionContext.getSource()).thenReturn(Optional.of(nodeA)); when(connectionContext.getTarget()).thenReturn(Optional.of(nodeB)); when(ruleExtension.getId()).thenReturn("anyOtherId"); when(ruleExtension.getTypeArguments()).thenReturn(new Class[]{ParentDefinition.class}); assertFalse(tested.accepts(ruleExtension, connectionContext)); } |
### Question:
CardinalityEvaluationHandler implements RuleEvaluationHandler<Occurrences, CardinalityContext> { @Override public boolean accepts(final Occurrences rule, final CardinalityContext context) { return context.getRoles().contains(rule.getRole()); } @Override Class<Occurrences> getRuleType(); @Override Class<CardinalityContext> getContextType(); @Override boolean accepts(final Occurrences rule,
final CardinalityContext context); @Override RuleViolations evaluate(final Occurrences rule,
final CardinalityContext context); }### Answer:
@Test public void testAccepts() { Set<String> roles = Collections.singleton(ROLE); when(context.getRoles()).thenReturn(roles); assertTrue(tested.accepts(RULE_NO_LIMIT, context)); roles = Collections.singleton("anotherTheRole"); when(context.getRoles()).thenReturn(roles); assertFalse(tested.accepts(RULE_NO_LIMIT, context)); } |
### Question:
ContainmentEvaluationHandler implements RuleEvaluationHandler<CanContain, ContainmentContext> { @Override public boolean accepts(final CanContain rule, final ContainmentContext context) { return context.getParentRoles().contains(rule.getRole()); } @Override Class<CanContain> getRuleType(); @Override Class<ContainmentContext> getContextType(); @Override boolean accepts(final CanContain rule,
final ContainmentContext context); @Override RuleViolations evaluate(final CanContain rule,
final ContainmentContext context); }### Answer:
@Test public void testAccepts() { Set<String> candidateRoles = Collections.singleton("role2"); Set<String> parentRoles = Collections.singleton(PARENT_ID); when(context.getParentRoles()).thenReturn(parentRoles); when(context.getCandidateRoles()).thenReturn(candidateRoles); assertTrue(tested.accepts(RULE, context)); parentRoles = Collections.singleton("otherParent"); when(context.getParentRoles()).thenReturn(parentRoles); assertFalse(tested.accepts(RULE, context)); } |
### Question:
ContainmentEvaluationHandler implements RuleEvaluationHandler<CanContain, ContainmentContext> { @Override public RuleViolations evaluate(final CanContain rule, final ContainmentContext context) { final DefaultRuleViolations results = new DefaultRuleViolations(); final boolean present = context.getCandidateRoles() .stream() .filter(cr -> rule.getAllowedRoles().contains(cr)) .findAny() .isPresent(); if (!present) { results.addViolation(new ContainmentRuleViolation(rule.getRole(), context.getCandidateRoles().toString())); } return results; } @Override Class<CanContain> getRuleType(); @Override Class<ContainmentContext> getContextType(); @Override boolean accepts(final CanContain rule,
final ContainmentContext context); @Override RuleViolations evaluate(final CanContain rule,
final ContainmentContext context); }### Answer:
@Test public void testEvaluateSuccess() { final Set<String> candidateRoles = new HashSet<String>(1) {{ add("role2"); }}; when(context.getParentRoles()).thenReturn(PARENT_ROLES); when(context.getCandidateRoles()).thenReturn(candidateRoles); final RuleViolations violations = tested.evaluate(RULE, context); assertNotNull(violations); assertFalse(violations.violations(RuleViolation.Type.ERROR).iterator().hasNext()); }
@Test public void testEvaluateFailed() { final Set<String> candidateRoles = new HashSet<String>(1) {{ add("role4"); }}; when(context.getParentRoles()).thenReturn(PARENT_ROLES); when(context.getCandidateRoles()).thenReturn(candidateRoles); final RuleViolations violations = tested.evaluate(RULE, context); assertNotNull(violations); assertTrue(violations.violations(RuleViolation.Type.ERROR).iterator().hasNext()); } |
### Question:
NodeDockingEvaluationHandler implements RuleEvaluationHandler<CanDock, NodeDockingContext> { @Override public boolean accepts(final CanDock rule, final NodeDockingContext context) { final Set<String> parentLabels = evalUtils.getLabels(context.getParent()); return dockingHandler.accepts(rule, RuleEvaluationContextBuilder.DomainContexts.docking(parentLabels, Collections.emptySet())); } protected NodeDockingEvaluationHandler(); @Inject NodeDockingEvaluationHandler(final DefinitionManager definitionManager,
final DockingEvaluationHandler dockingHandler); @Override Class<CanDock> getRuleType(); @Override Class<NodeDockingContext> getContextType(); @Override boolean accepts(final CanDock rule,
final NodeDockingContext context); @Override RuleViolations evaluate(final CanDock rule,
final NodeDockingContext context); }### Answer:
@Test @SuppressWarnings("unchecked") public void testAcceptSuccess() { when(context.getParent()).thenReturn(parent); when(context.getCandidate()).thenReturn(candidate); final boolean accepts = tested.accepts(RULE, context); assertTrue(accepts); }
@Test @SuppressWarnings("unchecked") public void testAcceptFailed() { when(context.getParent()).thenReturn(element); when(context.getCandidate()).thenReturn(candidate); final boolean accepts = tested.accepts(RULE, context); assertFalse(accepts); } |
### Question:
NodeDockingEvaluationHandler implements RuleEvaluationHandler<CanDock, NodeDockingContext> { @Override public RuleViolations evaluate(final CanDock rule, final NodeDockingContext context) { final Node<? extends Definition<?>, ? extends Edge> target = context.getCandidate(); final Set<String> parentLabels = evalUtils.getLabels(context.getParent()); final Set<String> candidateLabels = evalUtils.getLabels(target); final DefaultRuleViolations result = new DefaultRuleViolations(); result.addViolations( dockingHandler .evaluate(rule, RuleEvaluationContextBuilder.DomainContexts.docking(parentLabels, candidateLabels)) ); return GraphEvaluationHandlerUtils.addViolationsSourceUUID(target.getUUID(), result); } protected NodeDockingEvaluationHandler(); @Inject NodeDockingEvaluationHandler(final DefinitionManager definitionManager,
final DockingEvaluationHandler dockingHandler); @Override Class<CanDock> getRuleType(); @Override Class<NodeDockingContext> getContextType(); @Override boolean accepts(final CanDock rule,
final NodeDockingContext context); @Override RuleViolations evaluate(final CanDock rule,
final NodeDockingContext context); }### Answer:
@Test @SuppressWarnings("unchecked") public void testEvaluateSuccess() { when(context.getCandidate()).thenReturn(candidate); final RuleViolations violations = tested.evaluate(RULE, context); assertNotNull(violations); assertFalse(violations.violations(RuleViolation.Type.ERROR).iterator().hasNext()); }
@Test @SuppressWarnings("unchecked") public void testEvaluateFailed() { when(context.getCandidate()).thenReturn(candidate); final RuleViolations violations = tested.evaluate(RULE_INVALID, context); assertNotNull(violations); assertTrue(violations.violations(RuleViolation.Type.ERROR).iterator().hasNext()); } |
### Question:
ElementCardinalityEvaluationHandler implements RuleEvaluationHandler<Occurrences, ElementCardinalityContext> { @Override @SuppressWarnings("unchecked") public boolean accepts(final Occurrences rule, final ElementCardinalityContext context) { final Collection<Element<? extends View<?>>> candidates = context.getCandidates(); return candidates.isEmpty() || candidates.stream().anyMatch(candidate -> accepts(rule, context, candidate)); } protected ElementCardinalityEvaluationHandler(); @Inject ElementCardinalityEvaluationHandler(final DefinitionManager definitionManager,
final CardinalityEvaluationHandler cardinalityEvaluationHandler); @Override Class<Occurrences> getRuleType(); @Override Class<ElementCardinalityContext> getContextType(); @Override @SuppressWarnings("unchecked") boolean accepts(final Occurrences rule,
final ElementCardinalityContext context); @Override @SuppressWarnings("unchecked") RuleViolations evaluate(final Occurrences rule,
final ElementCardinalityContext context); }### Answer:
@Test @SuppressWarnings("unchecked") public void testAcceptsNoOp() { when(context.getCandidates()).thenReturn(Collections.emptyList()); assertTrue(tested.accepts(RULE_NO_LIMIT, context)); }
@Test @SuppressWarnings("unchecked") public void testAccepts() { when(context.getOperation()).thenReturn(Optional.of(CardinalityContext.Operation.ADD)); when(context.getCandidates()).thenReturn(candidates); assertTrue(tested.accepts(RULE_NO_LIMIT, context)); when(context.getCandidates()).thenReturn(Collections.singleton(parent)); assertFalse(tested.accepts(RULE_NO_LIMIT, context)); } |
### Question:
DockingEvaluationHandler implements RuleEvaluationHandler<CanDock, DockingContext> { @Override public boolean accepts(final CanDock rule, final DockingContext context) { return context.getParentRoles().contains(rule.getRole()); } @Override Class<CanDock> getRuleType(); @Override Class<DockingContext> getContextType(); @Override boolean accepts(final CanDock rule,
final DockingContext context); @Override RuleViolations evaluate(final CanDock rule,
final DockingContext context); }### Answer:
@Test public void testAccepts() { Set<String> candidateRoles = Collections.singleton("role2"); Set<String> parentRoles = Collections.singleton(PARENT_ID); when(context.getParentRoles()).thenReturn(parentRoles); when(context.getCandidateRoles()).thenReturn(candidateRoles); assertTrue(tested.accepts(RULE, context)); parentRoles = Collections.singleton("anotherParent"); when(context.getParentRoles()).thenReturn(parentRoles); assertFalse(tested.accepts(RULE, context)); } |
### Question:
DockingEvaluationHandler implements RuleEvaluationHandler<CanDock, DockingContext> { @Override public RuleViolations evaluate(final CanDock rule, final DockingContext context) { final DefaultRuleViolations results = new DefaultRuleViolations(); final boolean present = context.getCandidateRoles() .stream() .filter(cr -> rule.getAllowedRoles().contains(cr)) .findAny() .isPresent(); if (!present) { results.addViolation(new DockingRuleViolation(rule.getRole(), context.getCandidateRoles().toString())); } return results; } @Override Class<CanDock> getRuleType(); @Override Class<DockingContext> getContextType(); @Override boolean accepts(final CanDock rule,
final DockingContext context); @Override RuleViolations evaluate(final CanDock rule,
final DockingContext context); }### Answer:
@Test public void testEvaluateSuccess() { final Set<String> candidateRoles = new HashSet<String>(1) {{ add("drole2"); }}; when(context.getParentRoles()).thenReturn(PARENT_ROLES); when(context.getCandidateRoles()).thenReturn(candidateRoles); final RuleViolations violations = tested.evaluate(RULE, context); assertNotNull(violations); assertFalse(violations.violations(RuleViolation.Type.ERROR).iterator().hasNext()); }
@Test public void testEvaluateFailed() { final Set<String> candidateRoles = new HashSet<String>(1) {{ add("drole4"); }}; when(context.getParentRoles()).thenReturn(PARENT_ROLES); when(context.getCandidateRoles()).thenReturn(candidateRoles); final RuleViolations violations = tested.evaluate(RULE, context); assertNotNull(violations); assertTrue(violations.violations(RuleViolation.Type.ERROR).iterator().hasNext()); } |
### Question:
NodeContainmentEvaluationHandler implements RuleEvaluationHandler<CanContain, NodeContainmentContext> { @Override public boolean accepts(final CanContain rule, final NodeContainmentContext context) { final Set<String> parenteLabels = evalUtils.getLabels(context.getParent()); return containmentHandler.accepts(rule, RuleEvaluationContextBuilder.DomainContexts.containment(parenteLabels, Collections.emptySet())); } protected NodeContainmentEvaluationHandler(); @Inject NodeContainmentEvaluationHandler(final DefinitionManager definitionManager,
final ContainmentEvaluationHandler containmentHandler); @Override Class<CanContain> getRuleType(); @Override Class<NodeContainmentContext> getContextType(); @Override boolean accepts(final CanContain rule,
final NodeContainmentContext context); @Override @SuppressWarnings("unchecked") RuleViolations evaluate(final CanContain rule,
final NodeContainmentContext context); }### Answer:
@Test @SuppressWarnings("unchecked") public void testAcceptSuccess() { when(context.getParent()).thenReturn(element); when(context.getCandidates()).thenReturn(candidates); final boolean accepts = tested.accepts(RULE, context); assertTrue(accepts); }
@Test @SuppressWarnings("unchecked") public void testAcceptFailed() { when(context.getParent()).thenReturn(parent); when(context.getCandidates()).thenReturn(candidates); final boolean accepts = tested.accepts(RULE, context); assertFalse(accepts); } |
### Question:
NodeContainmentEvaluationHandler implements RuleEvaluationHandler<CanContain, NodeContainmentContext> { @Override @SuppressWarnings("unchecked") public RuleViolations evaluate(final CanContain rule, final NodeContainmentContext context) { final Element<? extends Definition<?>> parent = context.getParent(); final Set<String> parentLabels = evalUtils.getLabels(parent); final DefaultRuleViolations result = new DefaultRuleViolations(); final Collection<Node<? extends Definition<?>, ? extends Edge>> candidates = context.getCandidates(); candidates.forEach(candidate -> result.addViolations(evaluate(rule, candidate.getUUID(), evalUtils.getLabels(candidate), parentLabels))); return result; } protected NodeContainmentEvaluationHandler(); @Inject NodeContainmentEvaluationHandler(final DefinitionManager definitionManager,
final ContainmentEvaluationHandler containmentHandler); @Override Class<CanContain> getRuleType(); @Override Class<NodeContainmentContext> getContextType(); @Override boolean accepts(final CanContain rule,
final NodeContainmentContext context); @Override @SuppressWarnings("unchecked") RuleViolations evaluate(final CanContain rule,
final NodeContainmentContext context); }### Answer:
@Test @SuppressWarnings("unchecked") public void testEvaluateSuccess() { when(context.getCandidates()).thenReturn(candidates); final RuleViolations violations = tested.evaluate(RULE, context); assertNotNull(violations); assertFalse(violations.violations(RuleViolation.Type.ERROR).iterator().hasNext()); }
@Test @SuppressWarnings("unchecked") public void testEvaluateFailed() { when(context.getCandidates()).thenReturn(candidates); final RuleViolations violations = tested.evaluate(RULE_INVALID, context); assertNotNull(violations); assertTrue(violations.violations(RuleViolation.Type.ERROR).iterator().hasNext()); } |
### Question:
EdgeCardinalityEvaluationHandler implements RuleEvaluationHandler<EdgeOccurrences, EdgeCardinalityContext> { @Override public boolean accepts(final EdgeOccurrences rule, final EdgeCardinalityContext context) { final EdgeCardinalityContext.Direction direction = rule.getDirection(); return context.getEdgeRole().equals(rule.getConnectorRole()) && direction.equals(context.getDirection()) && context.getRoles().contains(rule.getRole()); } @Override Class<EdgeOccurrences> getRuleType(); @Override Class<EdgeCardinalityContext> getContextType(); @Override boolean accepts(final EdgeOccurrences rule,
final EdgeCardinalityContext context); @Override RuleViolations evaluate(final EdgeOccurrences rule,
final EdgeCardinalityContext context); }### Answer:
@Test public void testAccept() { when(context.getDirection()).thenReturn(EdgeCardinalityContext.Direction.OUTGOING); assertFalse(tested.accepts(RULE_IN_MAX_1, context)); when(context.getDirection()).thenReturn(EdgeCardinalityContext.Direction.INCOMING); assertTrue(tested.accepts(RULE_IN_MAX_1, context)); when(context.getEdgeRole()).thenReturn("some-edge"); assertFalse(tested.accepts(RULE_IN_MAX_1, context)); when(context.getEdgeRole()).thenReturn(EDGE_ID); assertTrue(tested.accepts(RULE_IN_MAX_1, context)); when(context.getRoles()).thenReturn(Collections.singleton("some-role")); assertFalse(tested.accepts(RULE_IN_MAX_1, context)); } |
### Question:
ConnectionEvaluationHandler implements RuleEvaluationHandler<CanConnect, ConnectionContext> { @Override public boolean accepts(final CanConnect rule, final ConnectionContext context) { return rule.getRole().equals(context.getConnectorRole()); } @Override Class<CanConnect> getRuleType(); @Override Class<ConnectionContext> getContextType(); @Override boolean accepts(final CanConnect rule,
final ConnectionContext context); @Override RuleViolations evaluate(final CanConnect rule,
final ConnectionContext context); }### Answer:
@Test public void testAccepts() { when(context.getConnectorRole()).thenReturn(EDGE_ID); assertTrue(tested.accepts(RULE, context)); when(context.getConnectorRole()).thenReturn("anotherEdgeId"); assertFalse(tested.accepts(RULE, context)); } |
### Question:
DefaultRuleViolations implements RuleViolations { public DefaultRuleViolations clear() { violations.clear(); return this; } DefaultRuleViolations addViolations(final RuleViolations violations); DefaultRuleViolations addViolation(final RuleViolation violation); DefaultRuleViolations clear(); boolean isEmpty(); @Override Iterable<RuleViolation> violations(); @Override Iterable<RuleViolation> violations(final RuleViolation.Type violationType); @Override String toString(); }### Answer:
@Test public void testClear() { final DefaultRuleViolations violations = new DefaultRuleViolations() .addViolation(violationWarn) .addViolation(violationInfo) .addViolation(violationErr); violations.clear(); assertNotNull(violations); assertTrue(violations.isEmpty()); } |
### Question:
ReverseCommand implements Command<T, V> { @Override public CommandResult<V> allow(T context) { return command.allow(context); } ReverseCommand(Command<T, V> command); @Override CommandResult<V> allow(T context); @Override CommandResult<V> execute(T context); @Override CommandResult<V> undo(T context); }### Answer:
@Test public void testAllow() throws Exception { reverseCommand.allow(context); verify(command).allow(eq(context)); } |
### Question:
ReverseCommand implements Command<T, V> { @Override public CommandResult<V> execute(T context) { return command.undo(context); } ReverseCommand(Command<T, V> command); @Override CommandResult<V> allow(T context); @Override CommandResult<V> execute(T context); @Override CommandResult<V> undo(T context); }### Answer:
@Test public void testExecute() throws Exception { reverseCommand.execute(context); verify(command).undo(eq(context)); } |
### Question:
ReverseCommand implements Command<T, V> { @Override public CommandResult<V> undo(T context) { return command.execute(context); } ReverseCommand(Command<T, V> command); @Override CommandResult<V> allow(T context); @Override CommandResult<V> execute(T context); @Override CommandResult<V> undo(T context); }### Answer:
@Test public void testUndo() throws Exception { reverseCommand.undo(context); verify(command).execute(eq(context)); } |
### Question:
DeferredCompositeCommand extends AbstractCompositeCommand<T, V> { @Override public CommandResult<V> allow(final T context) { throw new IllegalStateException(ILLEGAL_ALLOW_MESSAGE); } DeferredCompositeCommand(final @MapsTo("reverse") boolean reverse); @Override CommandResult<V> allow(final T context); @Override CommandResult<V> execute(final T context); @Override boolean isUndoReverse(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testAllow() { compositeCommand = buildCompositeCommand(); expectedException.expectMessage(DeferredCompositeCommand.ILLEGAL_ALLOW_MESSAGE); compositeCommand.allow(commandExecutionContext); } |
### Question:
DeferredCompositeCommand extends AbstractCompositeCommand<T, V> { @Override public CommandResult<V> execute(final T context) { return executeCommands(context); } DeferredCompositeCommand(final @MapsTo("reverse") boolean reverse); @Override CommandResult<V> allow(final T context); @Override CommandResult<V> execute(final T context); @Override boolean isUndoReverse(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecuteSuccessful() { Command c1 = mockCommand(SUCCESS, SUCCESS); Command c2 = mockCommand(SUCCESS, SUCCESS); Command c3 = mockCommand(SUCCESS, SUCCESS); Command c4 = mockCommand(SUCCESS, SUCCESS); compositeCommand = buildCompositeCommand(c1, c2, c3, c4); compositeCommand.execute(commandExecutionContext); verifyAllowedAndExecuted(c1); verifyAllowedAndExecuted(c2); verifyAllowedAndExecuted(c3); verifyAllowedAndExecuted(c4); }
@Test @SuppressWarnings("unchecked") public void testExecuteWithExecutionFailure() { Command c1 = mockCommand(SUCCESS, SUCCESS); Command c2 = mockCommand(SUCCESS, failed()); Command c3 = mockCommand(SUCCESS, SUCCESS); Command c4 = mockCommand(SUCCESS, SUCCESS); compositeCommand = buildCompositeCommand(c1, c2, c3, c4); compositeCommand.execute(commandExecutionContext); verifyAllowedExecutedAndUnDone(c1); verifyAllowedAndExecuted(c2); verifyNeverUsed(c3); verifyNeverUsed(c4); } |
### Question:
CommandManagerImpl implements CommandManager<C, V> { @Override public CommandResult<V> allow(final C context, final Command<C, V> command) { return command.allow(context); } CommandManagerImpl(); @Override CommandResult<V> allow(final C context,
final Command<C, V> command); @Override CommandResult<V> execute(final C context,
final Command<C, V> command); @Override CommandResult<V> undo(final C context,
final Command<C, V> command); }### Answer:
@Test public void testAllow() { when(command.allow(context)).thenReturn(commandResult); CommandResult<Object> result = tested.allow(context, command); verify(command, times(1)).allow(eq(context)); verify(command, times(0)).execute(anyObject()); verify(command, times(0)).undo(anyObject()); assertNotNull(result); assertEquals(commandResult, result); } |
### Question:
CommandManagerImpl implements CommandManager<C, V> { @Override public CommandResult<V> execute(final C context, final Command<C, V> command) { return command.execute(context); } CommandManagerImpl(); @Override CommandResult<V> allow(final C context,
final Command<C, V> command); @Override CommandResult<V> execute(final C context,
final Command<C, V> command); @Override CommandResult<V> undo(final C context,
final Command<C, V> command); }### Answer:
@Test public void testExecute() { when(command.execute(context)).thenReturn(commandResult); CommandResult<Object> result = tested.execute(context, command); verify(command, times(1)).execute(eq(context)); verify(command, times(0)).allow(anyObject()); verify(command, times(0)).undo(anyObject()); assertNotNull(result); assertEquals(commandResult, result); } |
### Question:
CommandManagerImpl implements CommandManager<C, V> { @Override public CommandResult<V> undo(final C context, final Command<C, V> command) { return command.undo(context); } CommandManagerImpl(); @Override CommandResult<V> allow(final C context,
final Command<C, V> command); @Override CommandResult<V> execute(final C context,
final Command<C, V> command); @Override CommandResult<V> undo(final C context,
final Command<C, V> command); }### Answer:
@Test public void testUndo() { when(command.undo(context)).thenReturn(commandResult); CommandResult<Object> result = tested.undo(context, command); verify(command, times(1)).undo(eq(context)); verify(command, times(0)).execute(anyObject()); verify(command, times(0)).allow(anyObject()); assertNotNull(result); assertEquals(commandResult, result); } |
### Question:
AbstractProfileManager implements ProfileManager { @Override public Collection<Profile> getAllProfiles() { final List<Profile> result = new ArrayList<>(); getAllProfileInstances().forEach(result::add); return result; } @Override Collection<Profile> getAllProfiles(); @Override Profile getProfile(final String id); @Override Collection<Profile> getProfiles(final String definitionSetId); @Override Profile getProfile(final String definitionSetId,
final String id); }### Answer:
@Test public void testGetAllProfiles() { Collection<Profile> allProfiles = tested.getAllProfiles(); assertEquals(2, allProfiles.size()); assertTrue(allProfiles.contains(defaultProfile)); assertTrue(allProfiles.contains(domainProfile)); } |
### Question:
AbstractProfileManager implements ProfileManager { @Override public Profile getProfile(final String id) { return null != id ? getAllProfiles().stream().filter(profile -> profile.getProfileId().equals(id)).findFirst().orElse(null) : null; } @Override Collection<Profile> getAllProfiles(); @Override Profile getProfile(final String id); @Override Collection<Profile> getProfiles(final String definitionSetId); @Override Profile getProfile(final String definitionSetId,
final String id); }### Answer:
@Test public void testGetProfileById() { assertEquals(defaultProfile, tested.getProfile(PROFILE_DEFAULT_ID)); assertEquals(domainProfile, tested.getProfile(PROFILE_DOMAIN_ID)); assertNull(tested.getProfile("someOtherId")); }
@Test public void testGetProfileByDomainAndId() { assertEquals(defaultProfile, tested.getProfile(DEF_SET_ID, PROFILE_DEFAULT_ID)); assertEquals(domainProfile, tested.getProfile(DEF_SET_ID, PROFILE_DOMAIN_ID)); } |
### Question:
AbstractProfileManager implements ProfileManager { @Override public Collection<Profile> getProfiles(final String definitionSetId) { final Annotation qualifier = getQualifier().apply(definitionSetId); final List<Profile> result = new ArrayList<>(); selectProfileInstances(qualifier).forEach(result::add); result.add(getDefaultProfileInstance()); return result; } @Override Collection<Profile> getAllProfiles(); @Override Profile getProfile(final String id); @Override Collection<Profile> getProfiles(final String definitionSetId); @Override Profile getProfile(final String definitionSetId,
final String id); }### Answer:
@Test public void testGetProfilesByDomain() { Collection<Profile> domainProfiles = tested.getProfiles(DEF_SET_ID); assertEquals(2, domainProfiles.size()); assertTrue(domainProfiles.contains(defaultProfile)); assertTrue(domainProfiles.contains(domainProfile)); } |
### Question:
DomainProfileManager { public List<String> getAllDefinitions(final Metadata metadata) { return getDefinitionsByProfile(metadata.getDefinitionSetId(), metadata.getProfileId()); } @Inject DomainProfileManager(final DefinitionManager definitionManager,
final ProfileManager profileManager,
final FullProfile defaultProfile); List<String> getAllDefinitions(final Metadata metadata); Predicate<String> isDefinitionIdAllowed(final Metadata metadata); }### Answer:
@Test public void testGetAllDefinitions() { when(metadata.getProfileId()).thenReturn(DEFAULT_PROFILE.getProfileId()); List<String> allDefinitions = tested.getAllDefinitions(metadata); assertEquals(2, allDefinitions.size()); assertTrue(allDefinitions.contains(DEF1)); assertTrue(allDefinitions.contains(DEF2)); when(metadata.getProfileId()).thenReturn(PROFILE_DOMAIN_ID); List<String> domainDefinitions = tested.getAllDefinitions(metadata); assertEquals(1, domainDefinitions.size()); assertTrue(domainDefinitions.contains(DEF1)); assertFalse(domainDefinitions.contains(DEF2)); } |
### Question:
DomainProfileManager { public Predicate<String> isDefinitionIdAllowed(final Metadata metadata) { return getDefinitionProfile(metadata) .map(DomainProfile::definitionAllowedFilter) .orElse(defaultProfile.definitionAllowedFilter()); } @Inject DomainProfileManager(final DefinitionManager definitionManager,
final ProfileManager profileManager,
final FullProfile defaultProfile); List<String> getAllDefinitions(final Metadata metadata); Predicate<String> isDefinitionIdAllowed(final Metadata metadata); }### Answer:
@Test public void testIsDefinitionAllowed() { when(metadata.getProfileId()).thenReturn(DEFAULT_PROFILE.getProfileId()); assertTrue(tested.isDefinitionIdAllowed(metadata).test(DEF1)); assertTrue(tested.isDefinitionIdAllowed(metadata).test(DEF2)); when(metadata.getProfileId()).thenReturn(PROFILE_DOMAIN_ID); assertTrue(tested.isDefinitionIdAllowed(metadata).test(DEF1)); assertFalse(tested.isDefinitionIdAllowed(metadata).test(DEF2)); } |
### Question:
ControlPointValidations { public static void checkAddControlPoint(final ControlPoint[] controlPoints, final ControlPoint controlPoint, final int index) { if (isControlPointIndexInvalid.test(index)) { throw new IllegalArgumentException("The given index [" + index + "] for the new CP is not valid."); } if (isAddingControlPointIndexForbidden.test(controlPoints, index)) { throw new IllegalArgumentException("Cannot add a new CP at the given index [" + index + "]."); } if (isControlPointInvalid.test(controlPoint)) { throw new IllegalArgumentException("The given CP is not valid"); } } static void checkAddControlPoint(final ControlPoint[] controlPoints,
final ControlPoint controlPoint,
final int index); static void checkDeleteControlPoint(final ControlPoint[] controlPoints,
final int index); static void checkUpdateControlPoint(final ControlPoint[] controlPoints1,
final ControlPoint[] controlPoints2); static Predicate<Integer> isControlPointIndexInvalid; static Predicate<ControlPoint> isControlPointInvalid; static BiPredicate<ControlPoint[], Integer> isAddingControlPointIndexForbidden; static BiPredicate<ControlPoint[], Integer> isDeletingControlPointIndexForbidden; static BiPredicate<ControlPoint[], ControlPoint[]> cannotControlPointsBeUpdated; }### Answer:
@Test public void testValidCheckAddControlPoint() { ControlPoint cp = ControlPoint.build(1, 1); checkAddControlPoint(controlPoints, cp, 0); checkAddControlPoint(controlPoints, cp, 1); }
@Test(expected = IllegalArgumentException.class) public void testInvalidCheckAddControlPoint() { ControlPoint cp = ControlPoint.build(1, 1); checkAddControlPoint(controlPoints, cp, 2); }
@Test(expected = IllegalArgumentException.class) public void testInvalidCheckAddControlPoint2() { ControlPoint cp = ControlPoint.build(1, 1); checkAddControlPoint(controlPoints, cp, 3); } |
### Question:
ControlPointValidations { public static void checkDeleteControlPoint(final ControlPoint[] controlPoints, final int index) { if (isControlPointIndexInvalid.test(index)) { throw new IllegalArgumentException("The given index [" + index + "] for the new CP is not valid."); } if (isDeletingControlPointIndexForbidden.test(controlPoints, index)) { throw new IllegalArgumentException("Cannot delete a new CP at the given index [" + index + "]."); } } static void checkAddControlPoint(final ControlPoint[] controlPoints,
final ControlPoint controlPoint,
final int index); static void checkDeleteControlPoint(final ControlPoint[] controlPoints,
final int index); static void checkUpdateControlPoint(final ControlPoint[] controlPoints1,
final ControlPoint[] controlPoints2); static Predicate<Integer> isControlPointIndexInvalid; static Predicate<ControlPoint> isControlPointInvalid; static BiPredicate<ControlPoint[], Integer> isAddingControlPointIndexForbidden; static BiPredicate<ControlPoint[], Integer> isDeletingControlPointIndexForbidden; static BiPredicate<ControlPoint[], ControlPoint[]> cannotControlPointsBeUpdated; }### Answer:
@Test public void testValidCheckDeleteControlPoint() { checkDeleteControlPoint(controlPoints, 0); }
@Test(expected = IllegalArgumentException.class) public void testInvalidCheckDeleteControlPoint() { checkDeleteControlPoint(controlPoints, 1); }
@Test(expected = IllegalArgumentException.class) public void testInvalidCheckDeleteControlPoint2() { checkDeleteControlPoint(controlPoints, 2); } |
### Question:
ControlPointValidations { public static void checkUpdateControlPoint(final ControlPoint[] controlPoints1, final ControlPoint[] controlPoints2) { if (cannotControlPointsBeUpdated.test(controlPoints1, controlPoints2)) { throw new IllegalArgumentException("The control points cannot be updated, length differs " + "[" + length(controlPoints1) + ":" + length(controlPoints2) + "]."); } } static void checkAddControlPoint(final ControlPoint[] controlPoints,
final ControlPoint controlPoint,
final int index); static void checkDeleteControlPoint(final ControlPoint[] controlPoints,
final int index); static void checkUpdateControlPoint(final ControlPoint[] controlPoints1,
final ControlPoint[] controlPoints2); static Predicate<Integer> isControlPointIndexInvalid; static Predicate<ControlPoint> isControlPointInvalid; static BiPredicate<ControlPoint[], Integer> isAddingControlPointIndexForbidden; static BiPredicate<ControlPoint[], Integer> isDeletingControlPointIndexForbidden; static BiPredicate<ControlPoint[], ControlPoint[]> cannotControlPointsBeUpdated; }### Answer:
@Test public void testValidCheckUpdateControlPoints() { ControlPoint controlPoint2 = ControlPoint.build(1, 1); ControlPoint[] controlPoints2 = new ControlPoint[]{controlPoint2}; checkUpdateControlPoint(controlPoints, controlPoints2); }
@Test(expected = IllegalArgumentException.class) public void testInvalidCheckUpdateControlPoints() { ControlPoint[] controlPoints2 = new ControlPoint[0]; checkUpdateControlPoint(controlPoints, controlPoints2); } |
### Question:
Exceptions { public static <T> T swallow(final Supplier<T> supplier, final T defaultReturn) { try { return supplier.get(); } catch (Exception e) { LOGGER.debug("Exception swallowed", e.getMessage()); return defaultReturn; } } static T swallow(final Supplier<T> supplier, final T defaultReturn); }### Answer:
@Test public void swallowRuntimeException() { final String result = Exceptions.swallow(() -> methodThatThrowsRuntimeException(), DEFAULT_RESULT); assertEquals(result, DEFAULT_RESULT); }
@Test public void swallowException() { final String result = Exceptions.swallow(() -> methodThatThrowsException(), DEFAULT_RESULT); assertEquals(result, DEFAULT_RESULT); }
@Test public void swallowNoException() { final String result = Exceptions.swallow(() -> methodNoException(), DEFAULT_RESULT); assertEquals(result, RESULT); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.