method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
StunnerLienzoCore { @PostConstruct public void init() { LienzoCore.get().setDefaultImageSelectionMode(ImageSelectionMode.SELECT_BOUNDS); } @PostConstruct void init(); }### Answer:
@Test public void testInit() { ImageSelectionMode before = LienzoCore.get().getDefaultImageSelectionMode(); new StunnerLienzoCore().init(); ImageSelectionMode after = LienzoCore.get().getDefaultImageSelectionMode(); assertEquals(ImageSelectionMode.SELECT_NON_TRANSPARENT, before); assertEquals(ImageSelectionMode.SELECT_BOUNDS, after); } |
### Question:
WiresManagerFactoryImpl implements WiresManagerFactory { @Override public WiresManager newWiresManager(final Layer layer) { WiresManager wiresManager = WiresManager.get(layer); wiresManager.setWiresHandlerFactory(wiresHandlerFactory); wiresManager.setWiresControlFactory(wiresControlFactory); wiresManager.getMagnetManager().setMagnetDecorator(new StunnerMagnetDecorator()); return wiresManager; } protected WiresManagerFactoryImpl(); @Inject WiresManagerFactoryImpl(final WiresControlFactory wiresControlFactory,
final WiresHandlerFactory wiresHandlerFactory); @Override WiresManager newWiresManager(final Layer layer); }### Answer:
@Test public void newWiresManager() { WiresManager wiresManager = wiresManagerFactory.newWiresManager(layer); assertEquals(wiresManager.getControlFactory(), wiresControlFactory); assertEquals(wiresManager.getWiresHandlerFactory(), wiresHandlerFactory); MagnetDecorator magnetDecorator = (MagnetDecorator) Whitebox.getInternalState(wiresManager.getMagnetManager(), "m_magnetDecorator"); assertTrue(magnetDecorator instanceof StunnerMagnetDecorator); } |
### Question:
DelegateWiresCompositeControl implements WiresCompositeControl { @Override public void destroy() { getDelegate().destroy(); } @Override void useIndex(Supplier<WiresLayerIndex> index); @Override Context getContext(); @Override boolean isAllowed(); @Override WiresContainer getSharedParent(); @Override void execute(); @Override boolean accept(); @Override boolean isOutOfBounds(double dx, double dy); @Override void clear(); @Override void reset(); @Override void onMouseClick(MouseEvent event); @Override void onMouseDown(MouseEvent event); @Override void onMouseUp(MouseEvent event); @Override void onMoveStart(double x, double y); @Override boolean onMove(double dx, double dy); @Override void onMoveComplete(); @Override Point2D getAdjust(); @Override void destroy(); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(delegate, times(1)).destroy(); } |
### Question:
StunnerWiresHandlerFactory implements WiresHandlerFactory { @Override public WiresConnectorHandler newConnectorHandler(final WiresConnector wiresConnector, final WiresManager wiresManager) { return delegate.newConnectorHandler(wiresConnector, wiresManager); } StunnerWiresHandlerFactory(); StunnerWiresHandlerFactory(WiresHandlerFactory delegate); @Override WiresConnectorHandler newConnectorHandler(final WiresConnector wiresConnector,
final WiresManager wiresManager); @Override WiresControlPointHandler newControlPointHandler(final WiresConnector wiresConnector,
final WiresManager wiresManager); @Override WiresShapeHandler newShapeHandler(final WiresShape shape,
final WiresShapeHighlight<PickerPart.ShapePart> highlight,
final WiresManager wiresManager); }### Answer:
@Test public void newConnectorHandler() { WiresConnectorHandler wiresConnectorHandler = tested.newConnectorHandler(connector, wiresManager); verify(delegate).newConnectorHandler(connector, wiresManager); } |
### Question:
StunnerWiresHandlerFactory implements WiresHandlerFactory { @Override public WiresControlPointHandler newControlPointHandler(final WiresConnector wiresConnector, final WiresManager wiresManager) { return delegate.newControlPointHandler(wiresConnector, wiresManager); } StunnerWiresHandlerFactory(); StunnerWiresHandlerFactory(WiresHandlerFactory delegate); @Override WiresConnectorHandler newConnectorHandler(final WiresConnector wiresConnector,
final WiresManager wiresManager); @Override WiresControlPointHandler newControlPointHandler(final WiresConnector wiresConnector,
final WiresManager wiresManager); @Override WiresShapeHandler newShapeHandler(final WiresShape shape,
final WiresShapeHighlight<PickerPart.ShapePart> highlight,
final WiresManager wiresManager); }### Answer:
@Test public void newControlPointHandler() { tested.newControlPointHandler(connector, wiresManager); verify(delegate).newControlPointHandler(connector, wiresManager); } |
### Question:
StunnerWiresHandlerFactory implements WiresHandlerFactory { @Override public WiresShapeHandler newShapeHandler(final WiresShape shape, final WiresShapeHighlight<PickerPart.ShapePart> highlight, final WiresManager wiresManager) { return delegate.newShapeHandler(shape, highlight, wiresManager); } StunnerWiresHandlerFactory(); StunnerWiresHandlerFactory(WiresHandlerFactory delegate); @Override WiresConnectorHandler newConnectorHandler(final WiresConnector wiresConnector,
final WiresManager wiresManager); @Override WiresControlPointHandler newControlPointHandler(final WiresConnector wiresConnector,
final WiresManager wiresManager); @Override WiresShapeHandler newShapeHandler(final WiresShape shape,
final WiresShapeHighlight<PickerPart.ShapePart> highlight,
final WiresManager wiresManager); }### Answer:
@Test public void newShapeHandler() { tested.newShapeHandler(shape, highlight, wiresManager); verify(delegate).newShapeHandler(shape, highlight, wiresManager); } |
### Question:
StunnerWiresShapeHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, HIGHLIGHT_COLOR); } StunnerWiresShapeHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeHighlight(final Event<CanvasUnhighlightEvent> unhighlightEvent,
final WiresShapeHighlightImpl delegate); @Override void highlight(final WiresShape shape,
final PickerPart.ShapePart part); @Override void error(final WiresShape shape,
final PickerPart.ShapePart shapePart); @Override void restore(); }### Answer:
@Test public void testHighlightBodyForWiresShape() { tested.highlight(lienzoShape, PickerPart.ShapePart.BODY); verify(delegate, times(1)).highlight(eq(lienzoShape), eq(PickerPart.ShapePart.BODY)); } |
### Question:
StunnerWiresShapeHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { private void highlightBorder(final WiresShape shape) { delegate.highlight(shape, PickerPart.ShapePart.BORDER); } StunnerWiresShapeHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeHighlight(final Event<CanvasUnhighlightEvent> unhighlightEvent,
final WiresShapeHighlightImpl delegate); @Override void highlight(final WiresShape shape,
final PickerPart.ShapePart part); @Override void error(final WiresShape shape,
final PickerPart.ShapePart shapePart); @Override void restore(); }### Answer:
@Test public void testHighlightBorder() { tested.highlight(lienzoShape, PickerPart.ShapePart.BORDER); verify(delegate, times(1)).highlight(eq(lienzoShape), eq(PickerPart.ShapePart.BORDER)); } |
### Question:
StunnerWiresShapeHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void restore() { restoreAnimation(() -> { }); delegate.restore(); unhighlightEvent.fire(new CanvasUnhighlightEvent()); } StunnerWiresShapeHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeHighlight(final Event<CanvasUnhighlightEvent> unhighlightEvent,
final WiresShapeHighlightImpl delegate); @Override void highlight(final WiresShape shape,
final PickerPart.ShapePart part); @Override void error(final WiresShape shape,
final PickerPart.ShapePart shapePart); @Override void restore(); }### Answer:
@Test public void testRestore() { tested.highlightBody(stunnerShape, "color"); tested.restore(); verify(unhighlightEvent, times(1)).fire(any(CanvasUnhighlightEvent.class)); verify(delegate, times(1)).restore(); verify(decorator, times(2)).animate(any(AnimationTweener.class), any(AnimationProperties.class), anyDouble(), any(IAnimationCallback.class)); } |
### Question:
StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresShapeControl newShapeControl(final WiresShape shape, final WiresManager wiresManager) { return new StunnerWiresShapeControl(new WiresShapeControlImpl(shape)); } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); @Override WiresShapeControl newShapeControl(final WiresShape shape,
final WiresManager wiresManager); @Override WiresConnectorControl newConnectorControl(final WiresConnector connector,
final WiresManager wiresManager); @Override WiresConnectionControl newConnectionControl(final WiresConnector connector,
final boolean headNotTail,
final WiresManager wiresManager); @Override WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context,
final WiresManager wiresManager); @Override WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager); @Override WiresLayerIndex newIndex(final WiresManager manager); }### Answer:
@Test public void testNewShapeControl() { final WiresShapeControl wiresShapeControl = tested.newShapeControl(wiresShape, wiresManager); assertNotNull(wiresShapeControl); assertTrue(wiresShapeControl instanceof StunnerWiresShapeControl); } |
### Question:
StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresConnectorControl newConnectorControl(final WiresConnector connector, final WiresManager wiresManager) { final WiresConnectorControlImpl wiresConnectorControl = (WiresConnectorControlImpl) delegate.newConnectorControl(connector, wiresManager); wiresConnectorControl.setPointHandleDecorator(new StunnerPointHandleDecorator()); return wiresConnectorControl; } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); @Override WiresShapeControl newShapeControl(final WiresShape shape,
final WiresManager wiresManager); @Override WiresConnectorControl newConnectorControl(final WiresConnector connector,
final WiresManager wiresManager); @Override WiresConnectionControl newConnectionControl(final WiresConnector connector,
final boolean headNotTail,
final WiresManager wiresManager); @Override WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context,
final WiresManager wiresManager); @Override WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager); @Override WiresLayerIndex newIndex(final WiresManager manager); }### Answer:
@Test public void testNewConnectorControl() { assertEquals(connectorControl, tested.newConnectorControl(wiresConnector, wiresManager)); verify(connectorControl).setPointHandleDecorator(any(StunnerPointHandleDecorator.class)); } |
### Question:
StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresConnectionControl newConnectionControl(final WiresConnector connector, final boolean headNotTail, final WiresManager wiresManager) { return delegate.newConnectionControl(connector, headNotTail, wiresManager); } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); @Override WiresShapeControl newShapeControl(final WiresShape shape,
final WiresManager wiresManager); @Override WiresConnectorControl newConnectorControl(final WiresConnector connector,
final WiresManager wiresManager); @Override WiresConnectionControl newConnectionControl(final WiresConnector connector,
final boolean headNotTail,
final WiresManager wiresManager); @Override WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context,
final WiresManager wiresManager); @Override WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager); @Override WiresLayerIndex newIndex(final WiresManager manager); }### Answer:
@Test public void testNewConnectionControl() { assertEquals(connectionControl, tested.newConnectionControl(wiresConnector, true, wiresManager)); } |
### Question:
StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context, final WiresManager wiresManager) { return delegate.newCompositeControl(context, wiresManager); } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); @Override WiresShapeControl newShapeControl(final WiresShape shape,
final WiresManager wiresManager); @Override WiresConnectorControl newConnectorControl(final WiresConnector connector,
final WiresManager wiresManager); @Override WiresConnectionControl newConnectionControl(final WiresConnector connector,
final boolean headNotTail,
final WiresManager wiresManager); @Override WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context,
final WiresManager wiresManager); @Override WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager); @Override WiresLayerIndex newIndex(final WiresManager manager); }### Answer:
@Test public void testNewCompositeControl() { assertEquals(compositeControl, tested.newCompositeControl(compositeContext, wiresManager)); } |
### Question:
StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager) { return new StunnerWiresShapeStateHighlight(wiresManager, unhighlightEvent); } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); @Override WiresShapeControl newShapeControl(final WiresShape shape,
final WiresManager wiresManager); @Override WiresConnectorControl newConnectorControl(final WiresConnector connector,
final WiresManager wiresManager); @Override WiresConnectionControl newConnectionControl(final WiresConnector connector,
final boolean headNotTail,
final WiresManager wiresManager); @Override WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context,
final WiresManager wiresManager); @Override WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager); @Override WiresLayerIndex newIndex(final WiresManager manager); }### Answer:
@Test public void testNewShapeHighlight() { final WiresShapeHighlight<PickerPart.ShapePart> instance = tested.newShapeHighlight(wiresManager); assertNotNull(instance); assertTrue(instance instanceof StunnerWiresShapeStateHighlight); } |
### Question:
StunnerPointHandleDecorator extends PointHandleDecorator { @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case NONE: case VALID: shape.setFillColor(MAIN_COLOR) .setFillAlpha(0.8) .setStrokeAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeWidth(2) .setStrokeColor(STROKE_COLOR); break; case INVALID: shape.setFillColor(ColorName.WHITE) .setFillAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeAlpha(1) .setStrokeWidth(2) .setStrokeColor(MAIN_COLOR); break; } return shape; } @Override Shape decorate(Shape shape, ShapeState state); static final String MAIN_COLOR; static final String STROKE_COLOR; }### Answer:
@Test public void decorateValidNone() { tested.decorate(shape, IShapeDecorator.ShapeState.VALID); tested.decorate(shape, IShapeDecorator.ShapeState.NONE); verify(shape, times(2)).setFillColor(StunnerPointHandleDecorator.MAIN_COLOR); verify(shape, times(2)).setFillAlpha(0.8); verify(shape, times(2)).setStrokeAlpha(1); verify(shape, times(2)).setShadow(SHADOW_SELECTED); verify(shape, times(2)).setStrokeWidth(2); verify(shape, times(2)).setStrokeColor(StunnerPointHandleDecorator.STROKE_COLOR); }
@Test public void decorateInvalid() { tested.decorate(shape, IShapeDecorator.ShapeState.INVALID); verify(shape).setFillColor(ColorName.WHITE); verify(shape).setShadow(SHADOW_SELECTED); verify(shape).setFillAlpha(1); verify(shape).setStrokeAlpha(1); verify(shape).setStrokeWidth(2); verify(shape).setStrokeColor(StunnerPointHandleDecorator.MAIN_COLOR); } |
### Question:
StunnerMagnetDecorator extends MagnetDecorator { @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case VALID: case INVALID: case NONE: shape.setFillColor(StunnerPointHandleDecorator.MAIN_COLOR) .setFillAlpha(0.7) .setStrokeAlpha(1) .setStrokeWidth(0) .moveToTop(); } return shape; } @Override Shape decorate(Shape shape, ShapeState state); }### Answer:
@Test public void decorate() { tested.decorate(shape, IShapeDecorator.ShapeState.VALID); tested.decorate(shape, IShapeDecorator.ShapeState.INVALID); tested.decorate(shape, IShapeDecorator.ShapeState.NONE); verify(shape, times(3)).setFillColor("#0088CE"); verify(shape, times(3)).setFillAlpha(0.7); verify(shape, times(3)).setStrokeAlpha(1); verify(shape, times(3)).setStrokeWidth(0); verify(shape, times(3)).moveToTop(); } |
### Question:
StunnerWiresShapeControl extends DelegateWiresShapeControl { @Override public void onMoveStart(final double x, final double y) { super.onMoveStart(x, y); getShapeView().moveToTop(); } StunnerWiresShapeControl(final WiresShapeControlImpl delegate); @Override void onMoveStart(final double x,
final double y); @Override WiresShapeControlImpl getDelegate(); }### Answer:
@Test public void testMoveViewsTopTop() { tested.onMoveStart(10d, 10d); verify(delegate, times(1)).onMoveStart(eq(10d), eq(10d)); verify(shapeView, times(1)).moveToTop(); } |
### Question:
StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); @Override void highlight(final WiresShape shape,
final PickerPart.ShapePart part); @Override void error(final WiresShape shape,
final PickerPart.ShapePart shapePart); @Override void restore(); }### Answer:
@Test public void testHighlightBodyForNonHasShapeStateView() { tested.highlight(view, PickerPart.ShapePart.BODY); verify(delegate, times(1)).highlight(eq(view), eq(PickerPart.ShapePart.BODY)); verify(stateExecutor, never()).accept(any(ShapeState.class)); }
@Test public void testHighlightBodyForHasShapeStateView() { tested.highlight(viewWithState, PickerPart.ShapePart.BODY); verify(stateExecutor, times(1)).accept(eq(ShapeState.HIGHLIGHT)); verify(delegate, never()).highlight(eq(viewWithState), any(PickerPart.ShapePart.class)); }
@Test public void testHighlightBorderForNonStateView() { tested.highlight(view, PickerPart.ShapePart.BORDER); verify(delegate, times(1)).highlight(eq(view), eq(PickerPart.ShapePart.BORDER)); verify(stateExecutor, never()).accept(any(ShapeState.class)); }
@Test public void testHighlightBorderForStateView() { tested.highlight(viewWithState, PickerPart.ShapePart.BORDER); verify(delegate, times(1)).highlight(eq(viewWithState), eq(PickerPart.ShapePart.BORDER)); verify(stateExecutor, never()).accept(any(ShapeState.class)); } |
### Question:
StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void restore() { if (null != current && (Objects.isNull(currentPartState) || Objects.equals(PickerPart.ShapePart.BODY, currentPartState))) { current.applyState(ShapeState.NONE); setCurrent(null); } else { delegate.restore(); } currentPartState = null; } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); @Override void highlight(final WiresShape shape,
final PickerPart.ShapePart part); @Override void error(final WiresShape shape,
final PickerPart.ShapePart shapePart); @Override void restore(); }### Answer:
@Test public void testRestore() { tested.setCurrent(viewWithState); tested.restore(); verify(stateExecutor, times(1)).accept(eq(ShapeState.NONE)); verify(delegate, never()).highlight(eq(viewWithState), any(PickerPart.ShapePart.class)); } |
### Question:
LienzoLayer { public LienzoLayer add(final IPrimitive<?> shape) { if (layer.getChildNodes().contains(shape)) { LOGGER.log(Level.WARNING, "Cannot add a primitive shape into the layer twice!"); } else { layer.add(shape); } return this; } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); }### Answer:
@Test public void testAdd() { tested.add(shape); verify(layer, times(1)).add(eq(shape)); tested.add(emptyLayer); verify(scene, times(1)).add(eq(emptyLayer)); }
@Test public void testAddTwice() { when(layer.getChildNodes()).thenReturn(new NFastArrayList<>(shape)); tested.add(shape); verify(layer, never()).add(eq(shape)); } |
### Question:
LienzoLayer { public LienzoLayer delete(final IPrimitive<?> shape) { layer.remove(shape); return this; } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); }### Answer:
@Test public void testDelete() { tested.delete(shape); verify(layer, times(1)).remove(eq(shape)); } |
### Question:
LienzoLayer { public void remove(final Layer layer) { if (isReady()) { this.layer.getScene().remove(layer); } } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); }### Answer:
@Test public void testRemove() { tested.remove(emptyLayer); verify(scene, times(1)).remove(eq(emptyLayer)); } |
### Question:
PreviewDiagramScreen { @OnOpen @SuppressWarnings("unused") public void onOpen() { final ClientSession current = clientSessionManager.getCurrentSession(); if (Objects.nonNull(current)) { showPreview(current); } } protected PreviewDiagramScreen(); @Inject PreviewDiagramScreen(final SessionManager clientSessionManager,
final @Any @DMNEditor ManagedInstance<SessionDiagramPreview<AbstractSession>> sessionPreviews,
final View view,
final DMNDiagramsSession session); @OnStartup @SuppressWarnings("unused") void onStartup(final PlaceRequest placeRequest); @OnOpen @SuppressWarnings("unused") void onOpen(); @OnClose @SuppressWarnings("unused") void onClose(); @WorkbenchPartTitle @SuppressWarnings("unused") String getTitle(); @WorkbenchPartView @SuppressWarnings("unused") IsWidget getWidget(); @WorkbenchContextId @SuppressWarnings("unused") String getMyContextRef(); static final String SCREEN_ID; }### Answer:
@Test public void testOnOpen() { tested.onOpen(); verify(tested).showPreview(any()); } |
### Question:
LienzoLayer { public void clear() { layer.clear(); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); }### Answer:
@Test public void testClear() { tested.clear(); verify(layer, times(1)).clear(); } |
### Question:
LienzoLayer { public boolean isReady() { return null != layer.getScene(); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); }### Answer:
@Test public void testIsReady() { LienzoCustomLayer layer1 = mock(LienzoCustomLayer.class); LienzoLayer tested1 = new LienzoLayer(layer1); when(layer1.getScene()).thenReturn(scene); LienzoCustomLayer layer2 = mock(LienzoCustomLayer.class); LienzoLayer tested2 = new LienzoLayer(layer2); when(layer2.getScene()).thenReturn(null); assertTrue(tested1.isReady()); assertFalse(tested2.isReady()); } |
### Question:
LienzoLayer { public void onAfterDraw(final Command callback) { layer.setOnLayerAfterDraw(layer1 -> callback.execute()); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); }### Answer:
@Test public void testOnAfterDraw() { tested.onAfterDraw(mock(Command.class)); verify(layer, times(1)).setOnLayerAfterDraw(any(OnLayerAfterDraw.class)); } |
### Question:
LienzoLayer { public Layer getTopLayer() { return isReady() ? layer.getScene().getTopLayer() : null; } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); }### Answer:
@Test public void testGetTopLayer() { assertEquals(topLayer, tested.getTopLayer()); } |
### Question:
LienzoLayer { public void destroy() { layer.removeAll(); layer.removeFromParent(); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(layer, times(1)).removeAll(); verify(layer, times(1)).removeFromParent(); } |
### Question:
LienzoLayer { protected Point2D getTranslate() { return new Point2D( layer.getAbsoluteTransform().getTranslateX(), layer.getAbsoluteTransform().getTranslateY() ); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); }### Answer:
@Test public void testGetTranslate() { transform.translate(11, 33); Point2D translate = tested.getTranslate(); assertEquals(11d, translate.getX(), 0d); assertEquals(33d, translate.getY(), 0d); } |
### Question:
LienzoLayer { protected Point2D getScale() { return new Point2D( layer.getAbsoluteTransform().getScaleX(), layer.getAbsoluteTransform().getScaleY() ); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); }### Answer:
@Test public void testGetScale() { transform.scale(0.11, 0.666); Point2D translate = tested.getScale(); assertEquals(0.11d, translate.getX(), 0d); assertEquals(0.666d, translate.getY(), 0d); } |
### Question:
LienzoLayer { public void translate(final double tx, final double ty) { setTransform(t -> translate(t, tx, ty)); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); }### Answer:
@Test public void testTranslate() { tested.translate(11, 33); assertEquals(11d, transform.getTranslateX(), 0d); assertEquals(33d, transform.getTranslateY(), 0d); } |
### Question:
LienzoLayer { public void scale(final double sx, final double sy) { setTransform(t -> scale(t, sx, sy)); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); }### Answer:
@Test public void testScaleUnit() { tested.scale(0.22d); assertEquals(0.22d, transform.getScaleX(), 0d); assertEquals(0.22d, transform.getScaleY(), 0d); }
@Test public void testScaleUnits() { tested.scale(0.22d, 0.33d); assertEquals(0.22d, transform.getScaleX(), 0d); assertEquals(0.33d, transform.getScaleY(), 0d); } |
### Question:
PreviewDiagramScreen { @OnClose @SuppressWarnings("unused") public void onClose() { closePreview(); } protected PreviewDiagramScreen(); @Inject PreviewDiagramScreen(final SessionManager clientSessionManager,
final @Any @DMNEditor ManagedInstance<SessionDiagramPreview<AbstractSession>> sessionPreviews,
final View view,
final DMNDiagramsSession session); @OnStartup @SuppressWarnings("unused") void onStartup(final PlaceRequest placeRequest); @OnOpen @SuppressWarnings("unused") void onOpen(); @OnClose @SuppressWarnings("unused") void onClose(); @WorkbenchPartTitle @SuppressWarnings("unused") String getTitle(); @WorkbenchPartView @SuppressWarnings("unused") IsWidget getWidget(); @WorkbenchContextId @SuppressWarnings("unused") String getMyContextRef(); static final String SCREEN_ID; }### Answer:
@Test public void testOnClose() { tested.onClose(); verify(tested).closePreview(); } |
### Question:
ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @SuppressWarnings("unchecked") private static boolean eq(final Object n1, final Object n2) { if (n1 == null && n2 == null) { return true; } return null != n1 && n1.equals(n2); } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); }### Answer:
@Test public void testInit() { tested.init(canvasHandler); assertEquals(canvasHandler, tested.getCanvasHandler()); verify(highlight, times(1)).setCanvasHandler(eq(canvasHandler)); verify(wiresManager, times(1)).setConnectionAcceptor(any(IConnectionAcceptor.class)); verify(wiresManager, never()).setDockingAcceptor(any(IDockingAcceptor.class)); verify(wiresManager, never()).setContainmentAcceptor(any(IContainmentAcceptor.class)); } |
### Question:
ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean allowSource(final Node source, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { if (isSourceConnectionChanged(connector, connection)) { final CommandResult<CanvasViolation> violations = getCommandManager().allow(getCanvasHandler(), canvasCommandFactory.setSourceNode(source, connector, connection)); final boolean accepts = isAccept(violations); if (isSourceChanged(source, connector)) { highlight(source, connector, accepts); } return accepts; } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); }### Answer:
@Test public void testAllowSource() { tested.init(canvasHandler); final boolean allow = tested.allowSource(node, edge, connection); assertTrue(allow); verify(commandManager, times(1)).allow(eq(canvasHandler), eq(setConnectionSourceNodeCommand)); verify(commandManager, never()).execute(any(AbstractCanvasHandler.class), any(SetConnectionSourceNodeCommand.class)); assertEquals(node, setConnectionSourceNodeCommand.getNode()); assertEquals(edge, setConnectionSourceNodeCommand.getEdge()); assertEquals(connection, setConnectionSourceNodeCommand.getConnection()); verify(highlight, times(1)).unhighLight(); } |
### Question:
ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean allowTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { if (isTargetConnectionChanged(connector, connection)) { final CommandResult<CanvasViolation> violations = getCommandManager().allow(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); final boolean accepts = isAccept(violations); if (isTargetChanged(target, connector)) { highlight(target, connector, accepts); } return accepts; } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); }### Answer:
@Test public void testAllowTarget() { tested.init(canvasHandler); final boolean allow = tested.allowTarget(node, edge, connection); assertTrue(allow); verify(commandManager, times(1)).allow(eq(canvasHandler), eq(setConnectionTargetNodeCommand)); verify(commandManager, never()).execute(any(AbstractCanvasHandler.class), any(SetConnectionTargetNodeCommand.class)); assertEquals(node, setConnectionTargetNodeCommand.getNode()); assertEquals(edge, setConnectionTargetNodeCommand.getEdge()); assertEquals(connection, setConnectionTargetNodeCommand.getConnection()); verify(highlight, times(1)).unhighLight(); } |
### Question:
ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean acceptSource(final Node source, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isSourceChanged(source, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setSourceNode(source, connector, connection)); return isAccept(violations); } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); }### Answer:
@Test public void testAcceptSource() { tested.init(canvasHandler); final boolean allow = tested.acceptSource(node, edge, connection); assertTrue(allow); verify(commandManager, times(1)).execute(eq(canvasHandler), eq(setConnectionSourceNodeCommand)); verify(commandManager, never()).allow(any(AbstractCanvasHandler.class), any(SetConnectionSourceNodeCommand.class)); assertEquals(node, setConnectionSourceNodeCommand.getNode()); assertEquals(edge, setConnectionSourceNodeCommand.getEdge()); assertEquals(connection, setConnectionSourceNodeCommand.getConnection()); verify(highlight, times(1)).unhighLight(); } |
### Question:
ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean acceptTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isTargetChanged(target, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); return isAccept(violations); } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); }### Answer:
@Test public void testAcceptTarget() { tested.init(canvasHandler); final boolean allow = tested.acceptTarget(node, edge, connection); assertTrue(allow); verify(commandManager, times(1)).execute(eq(canvasHandler), eq(setConnectionTargetNodeCommand)); verify(commandManager, never()).allow(any(AbstractCanvasHandler.class), any(SetConnectionSourceNodeCommand.class)); assertEquals(node, setConnectionTargetNodeCommand.getNode()); assertEquals(edge, setConnectionTargetNodeCommand.getEdge()); assertEquals(connection, setConnectionTargetNodeCommand.getConnection()); verify(highlight, times(1)).unhighLight(); }
@Test public void testAcceptTargetNotNewConnection() { when(edge.getTargetNode()).thenReturn(node); tested.init(canvasHandler); final boolean allow = tested.acceptTarget(node, edge, connection); assertTrue(allow); verify(commandManager, never()).allow(any(AbstractCanvasHandler.class), any(SetConnectionTargetNodeCommand.class)); verify(highlight, times(1)).unhighLight(); } |
### Question:
ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { public static Connection createConnection(final WiresConnection wiresConnection, final WiresMagnet wiresMagnet) { if (null == wiresMagnet && null == wiresConnection) { return null; } if (null == wiresMagnet) { return Point2DConnection.at(Point2D.create(wiresConnection.getPoint().getX(), wiresConnection.getPoint().getY())); } return new MagnetConnection.Builder() .atX(wiresMagnet.getX()) .atY(wiresMagnet.getY()) .auto(null != wiresConnection && wiresConnection.isAutoConnection()) .magnet(wiresMagnet.getIndex()) .build(); } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); }### Answer:
@Test public void testCreateConnections() { Element element = mock(Element.class); View<?> content = mock(View.class); Bounds bounds = Bounds.create(0d, 0d, 10d, 20d); when(element.getContent()).thenReturn(content); when(content.getBounds()).thenReturn(bounds); MagnetConnection c1 = ConnectionAcceptorControlImpl.createConnection(element); assertEquals(5, c1.getLocation().getX(), 0); assertEquals(10, c1.getLocation().getY(), 0); assertEquals(MagnetConnection.MAGNET_CENTER, c1.getMagnetIndex().getAsInt()); assertFalse(c1.isAuto()); WiresConnection wiresConnection = mock(WiresConnection.class); when(wiresConnection.isAutoConnection()).thenReturn(true); WiresMagnet wiresMagnet = mock(WiresMagnet.class); when(wiresMagnet.getX()).thenReturn(122d); when(wiresMagnet.getY()).thenReturn(543d); when(wiresMagnet.getIndex()).thenReturn(7); MagnetConnection c2 = (MagnetConnection) ConnectionAcceptorControlImpl.createConnection(wiresConnection, wiresMagnet); assertEquals(122, c2.getLocation().getX(), 0); assertEquals(543, c2.getLocation().getY(), 0); assertEquals(7, c2.getMagnetIndex().getAsInt()); assertTrue(c2.isAuto()); when(wiresConnection.getPoint()).thenReturn(new Point2D(122d, 543d)); final Connection pointConnection = ConnectionAcceptorControlImpl.createConnection(wiresConnection, null); assertEquals(122d, pointConnection.getLocation().getX(), 0); assertEquals(543d, pointConnection.getLocation().getY(), 0); assertNull(ConnectionAcceptorControlImpl.createConnection(null)); assertNull(ConnectionAcceptorControlImpl.createConnection(null, null)); } |
### Question:
ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void addControlPoint(final Edge candidate, final ControlPoint controlPoint, final int index) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, candidate.getUUID())); execute(canvasCommandFactory.addControlPoint(candidate, controlPoint, index)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); @Override void register(final Element element); @Override void addControlPoint(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override void updateControlPoints(final Edge candidate,
final ControlPoint[] controlPoints); @Override void deleteControlPoint(final Edge candidate,
final int index); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); }### Answer:
@Test @SuppressWarnings("unchecked") public void testAddControlPoint() { final int index = 1; final ControlPoint controlPoint = ControlPoint.build(2, 2); CanvasCommand<AbstractCanvasHandler> addControlPointCommand = mock(CanvasCommand.class); doReturn(addControlPointCommand).when(canvasCommandFactory).addControlPoint(eq(edge), eq(controlPoint), eq(index)); tested.init(canvasHandler); tested.addControlPoint(edge, controlPoint, index); ArgumentCaptor<Command> commandArgumentCaptor = ArgumentCaptor.forClass(Command.class); verify(commandManager, times(1)).execute(eq(canvasHandler), commandArgumentCaptor.capture()); Command<AbstractCanvasHandler, CanvasViolation> command = commandArgumentCaptor.getValue(); assertEquals(addControlPointCommand, command); }
@Test public void testStunnerControlPointsAcceptorAdd() { final HandlerRegistration mouseUpHandlerRegistration = mock(HandlerRegistration.class); final NodeMouseUpHandler[] mouseUpHandlerCaptured = new NodeMouseUpHandler[1]; doAnswer(invocationOnMock -> { mouseUpHandlerCaptured[0] = (NodeMouseUpHandler) invocationOnMock.getArguments()[0]; mouseUpHandlerCaptured[0].onNodeMouseUp(mock(NodeMouseUpEvent.class)); return mouseUpHandlerRegistration; }).when(layer).addNodeMouseUpHandler(any(NodeMouseUpHandler.class)); ControlPointControl control = mock(ControlPointControl.class); ControlPointControlImpl.StunnerControlPointsAcceptor acceptor = createStunnerControlPointsAcceptor(control); boolean addResult = acceptor.add(connector, 1, new com.ait.lienzo.client.core.types.Point2D(2, 2)); assertTrue(addResult); verify(connector, times(1)).addControlPoint(eq(2d), eq(2d), eq(1)); verify(control, times(1)).addControlPoint(eq(edge), eq(ControlPoint.build(2, 2)), eq(0)); } |
### Question:
ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void deleteControlPoint(final Edge candidate, final int index) { execute(canvasCommandFactory.deleteControlPoint(candidate, index)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); @Override void register(final Element element); @Override void addControlPoint(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override void updateControlPoints(final Edge candidate,
final ControlPoint[] controlPoints); @Override void deleteControlPoint(final Edge candidate,
final int index); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); }### Answer:
@Test @SuppressWarnings("unchecked") public void testDeleteControlPoint() { CanvasCommand<AbstractCanvasHandler> deleteControlPointCommand = mock(CanvasCommand.class); doReturn(deleteControlPointCommand).when(canvasCommandFactory).deleteControlPoint(eq(edge), eq(0)); tested.init(canvasHandler); tested.deleteControlPoint(edge, 0); ArgumentCaptor<Command> commandArgumentCaptor = ArgumentCaptor.forClass(Command.class); verify(commandManager, times(1)).execute(eq(canvasHandler), commandArgumentCaptor.capture()); Command<AbstractCanvasHandler, CanvasViolation> command = commandArgumentCaptor.getValue(); assertEquals(deleteControlPointCommand, command); }
@Test public void testStunnerControlPointsAcceptorDelete() { ControlPointControl control = mock(ControlPointControl.class); ControlPointControlImpl.StunnerControlPointsAcceptor acceptor = createStunnerControlPointsAcceptor(control); final boolean deleteResult = acceptor.delete(connector, 1); assertTrue(deleteResult); verify(control, times(1)).deleteControlPoint(eq(edge), eq(0)); } |
### Question:
PreviewDiagramScreen { @WorkbenchPartView @SuppressWarnings("unused") public IsWidget getWidget() { return view; } protected PreviewDiagramScreen(); @Inject PreviewDiagramScreen(final SessionManager clientSessionManager,
final @Any @DMNEditor ManagedInstance<SessionDiagramPreview<AbstractSession>> sessionPreviews,
final View view,
final DMNDiagramsSession session); @OnStartup @SuppressWarnings("unused") void onStartup(final PlaceRequest placeRequest); @OnOpen @SuppressWarnings("unused") void onOpen(); @OnClose @SuppressWarnings("unused") void onClose(); @WorkbenchPartTitle @SuppressWarnings("unused") String getTitle(); @WorkbenchPartView @SuppressWarnings("unused") IsWidget getWidget(); @WorkbenchContextId @SuppressWarnings("unused") String getMyContextRef(); static final String SCREEN_ID; }### Answer:
@Test public void testView() { assertEquals(view, tested.getWidget()); } |
### Question:
ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void updateControlPoints(final Edge candidate, final ControlPoint[] controlPoints) { execute(canvasCommandFactory.updateControlPointPosition(candidate, controlPoints)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); @Override void register(final Element element); @Override void addControlPoint(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override void updateControlPoints(final Edge candidate,
final ControlPoint[] controlPoints); @Override void deleteControlPoint(final Edge candidate,
final int index); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); }### Answer:
@Test public void testStunnerControlPointsAcceptorMove() { ControlPointControl control = mock(ControlPointControl.class); ControlPointControlImpl.StunnerControlPointsAcceptor acceptor = createStunnerControlPointsAcceptor(control); Point2DArray locationArray = new Point2DArray(new com.ait.lienzo.client.core.types.Point2D(0, 0), new com.ait.lienzo.client.core.types.Point2D(5, 5), new com.ait.lienzo.client.core.types.Point2D(10, 10)); final boolean moveResult = acceptor.move(connector, locationArray); assertTrue(moveResult); ArgumentCaptor<ControlPoint[]> controlPointsExpected = ArgumentCaptor.forClass(ControlPoint[].class); verify(control, times(1)).updateControlPoints(eq(edge), controlPointsExpected.capture()); ControlPoint[] cps = controlPointsExpected.getValue(); assertNotNull(cps); assertEquals(1, cps.length); assertEquals(ControlPoint.build(5, 5), cps[0]); } |
### Question:
LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @SuppressWarnings("unchecked") private static void ensureDragConstraints(final AbstractCanvas<?> canvas, final ShapeView shapeView) { final Bounds bounds = canvas.getView().getPanel().getLocationConstraints(); ShapeUtils.enforceLocationConstraints(shapeView, bounds); } protected LocationControlImpl(); @Inject LocationControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<ShapeLocationsChangedEvent> shapeLocationsChangedEvent,
final Event<CanvasSelectionEvent> selectionEvent); Collection<String> getSelectedIDs(); @Override void bind(final EditorSession session); void handleArrowKeys(final Key... keys); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> move(final Element[] elements,
final Point2D[] locations); }### Answer:
@Test public void testEnsureDragConstraints() throws Exception { tested.init(canvasHandler); Bounds bounds = Bounds.create(0d, 0d, 600d, 600d); when(canvasPanel.getLocationConstraints()).thenReturn(bounds); tested.register(element); verify(shapeView, times(1)).setDragBounds(eq(bounds)); } |
### Question:
DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean allow(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().allow(getCanvasHandler(), command)); } @Inject DockingAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override boolean allow(final Node parent,
final Node child); @Override boolean accept(final Node parent,
final Node child); }### Answer:
@Test public void testAllow() { tested.init(canvasHandler); final boolean allow = tested.allow(source, docked); assertTrue(allow); verify(commandManager, times(1)).allow(eq(canvasHandler), eq(updateDockNodeCommand)); assertEquals(source, updateDockNodeCommand.getParent()); assertEquals(docked, updateDockNodeCommand.getCandidate()); }
@Test public void testAllowNoParent() { tested.init(canvasHandler); final boolean allow = tested.allow(null, docked); assertFalse(allow); verify(commandManager, times(0)).allow(any(AbstractCanvasHandler.class), any(UpdateDockNodeCommand.class)); } |
### Question:
DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean accept(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().execute(getCanvasHandler(), command)); } @Inject DockingAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override boolean allow(final Node parent,
final Node child); @Override boolean accept(final Node parent,
final Node child); }### Answer:
@Test public void testAccept() { tested.init(canvasHandler); final boolean accept = tested.accept(source, docked); assertTrue(accept); verify(commandManager, times(1)).execute(eq(canvasHandler), eq(updateDockNodeCommand)); assertEquals(source, updateDockNodeCommand.getParent()); assertEquals(docked, updateDockNodeCommand.getCandidate()); }
@Test public void testAceeptNoParent() { tested.init(canvasHandler); final boolean accept = tested.accept(null, docked); assertFalse(accept); verify(commandManager, times(0)).execute(any(AbstractCanvasHandler.class), any(UpdateDockNodeCommand.class)); } |
### Question:
PreviewDiagramScreen { void showPreview(final ClientSession session) { if (Objects.isNull(session)) { return; } if (session instanceof AbstractSession) { if (Objects.nonNull(previewWidget)) { closePreview(); } previewWidget = sessionPreviews.get(); previewWidget.open((AbstractSession) session, PREVIEW_WIDTH, PREVIEW_HEIGHT, new SessionViewer.SessionViewerCallback<Diagram>() { @Override public void afterCanvasInitialized() { } @Override public void onSuccess() { view.setPreviewWidget(previewWidget.getView()); } @Override public void onError(final ClientRuntimeError error) { LOGGER.log(Level.SEVERE, error.getMessage()); } }); } } protected PreviewDiagramScreen(); @Inject PreviewDiagramScreen(final SessionManager clientSessionManager,
final @Any @DMNEditor ManagedInstance<SessionDiagramPreview<AbstractSession>> sessionPreviews,
final View view,
final DMNDiagramsSession session); @OnStartup @SuppressWarnings("unused") void onStartup(final PlaceRequest placeRequest); @OnOpen @SuppressWarnings("unused") void onOpen(); @OnClose @SuppressWarnings("unused") void onClose(); @WorkbenchPartTitle @SuppressWarnings("unused") String getTitle(); @WorkbenchPartView @SuppressWarnings("unused") IsWidget getWidget(); @WorkbenchContextId @SuppressWarnings("unused") String getMyContextRef(); static final String SCREEN_ID; }### Answer:
@Test @SuppressWarnings("unchecked") public void testShowPreview() { tested.showPreview(session); verify(sessionPreview).open(eq(session), anyInt(), anyInt(), sessionViewerCallbackArgumentCaptor.capture()); final SessionViewer.SessionViewerCallback sessionViewerCallback = sessionViewerCallbackArgumentCaptor.getValue(); sessionViewerCallback.onSuccess(); verify(sessionPreview, never()).clear(); verify(view).setPreviewWidget(previewWidget); } |
### Question:
LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> setMinScale(final double minScale) { mediators.setMinScale(minScale); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); }### Answer:
@Test public void testSetMinScale() { tested.setMinScale(0.4d); verify(mediators, times(1)).setMinScale(eq(0.4d)); } |
### Question:
LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> setMaxScale(final double maxScale) { mediators.setMaxScale(maxScale); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); }### Answer:
@Test public void testSetMaxScale() { tested.setMaxScale(0.4d); verify(mediators, times(1)).setMaxScale(eq(0.4d)); } |
### Question:
LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> setZoomFactor(final double factor) { mediators.setZoomFactor(factor); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); }### Answer:
@Test public void testSetZoomFactor() { tested.setZoomFactor(0.4d); verify(mediators, times(1)).setZoomFactor(eq(0.4d)); } |
### Question:
LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> scale(final double factor) { getLayer().scale(factor); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); }### Answer:
@Test public void testScale() { tested.scale(0.2d, 0.4d); verify(layer, times(1)).scale(0.2d, 0.4d); tested.scale(0.5d); verify(layer, times(1)).scale(0.5d); } |
### Question:
LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> translate(final double tx, final double ty) { getLayer().translate(tx, ty); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); }### Answer:
@Test public void testTranslate() { tested.translate(0.2d, 0.4d); verify(layer, times(1)).translate(0.2d, 0.4d); } |
### Question:
LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { void onCanvasFocusedEvent(final @Observes CanvasFocusedEvent focusedEvent) { if (null != canvas && canvas.equals(focusedEvent.getCanvas())) { mediators.enable(); } } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); }### Answer:
@Test public void testOnCanvasFocusedEvent() { CanvasFocusedEvent event = new CanvasFocusedEvent(canvas); tested.onCanvasFocusedEvent(event); verify(mediators, times(1)).enable(); verify(mediators, never()).disable(); } |
### Question:
LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { void onCanvasLostFocusEvent(final @Observes CanvasLostFocusEvent lostFocusEvent) { if (null != canvas && canvas.equals(lostFocusEvent.getCanvas())) { mediators.disable(); } } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); }### Answer:
@Test public void testOnCanvasLostFocusEvent() { CanvasLostFocusEvent event = new CanvasLostFocusEvent(canvas); tested.onCanvasLostFocusEvent(event); verify(mediators, times(1)).disable(); verify(mediators, never()).enable(); } |
### Question:
LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { void onCanvasSelection(final @Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { onClearSelection(); } selectionShapeProvider.moveShapeToTop(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); }### Answer:
@Test public void testGroupSelectionWithMultipleItems() { final SelectionManager.SelectedItems selectedItems = mock(SelectionManager.SelectedItems.class); final LienzoMultipleSelectionControl.CursoredSelectionShapeProvider ssp = mock(LienzoMultipleSelectionControl.CursoredSelectionShapeProvider.class); tested = new LienzoMultipleSelectionControl<>(selectionControl, canvasSelectionEvent, clearSelectionEvent, ssp); tested.init(canvasHandler); when(selectionManager.getSelectedItems()).thenReturn(selectedItems); when(selectionManager.getSelectedItems().isSelectionGroup()).thenReturn(true); tested.onCanvasSelection(new CanvasSelectionEvent(canvasHandler, Arrays.asList(ELEMENT_UUID, ELEMENT_UUID_2, ELEMENT_UUID_3, ELEMENT_UUID_4, ELEMENT_UUID_5))); verify(selectionControl, never()).clearSelection(); verify(selectionManager, never()).clearSelection(); }
@Test public void testSingleSelectionFromGroupSelection() { final SelectionManager.SelectedItems selectedItems = mock(SelectionManager.SelectedItems.class); final LienzoMultipleSelectionControl.CursoredSelectionShapeProvider ssp = mock(LienzoMultipleSelectionControl.CursoredSelectionShapeProvider.class); tested = new LienzoMultipleSelectionControl<>(selectionControl, canvasSelectionEvent, clearSelectionEvent, ssp); tested.init(canvasHandler); when(selectionManager.getSelectedItems()).thenReturn(selectedItems); when(selectionManager.getSelectedItems().isSelectionGroup()).thenReturn(true); tested.onCanvasSelection(new CanvasSelectionEvent(canvasHandler, Arrays.asList(ELEMENT_UUID))); verify(selectionControl, never()).clearSelection(); verify(selectionManager, times(1)).clearSelection(); }
@Test public void testMoveSelectionShapeToTop() { final LienzoMultipleSelectionControl.CursoredSelectionShapeProvider ssp = mock(LienzoMultipleSelectionControl.CursoredSelectionShapeProvider.class); tested = new LienzoMultipleSelectionControl<>(selectionControl, canvasSelectionEvent, clearSelectionEvent, ssp); tested.init(canvasHandler); tested.onCanvasSelection(new CanvasSelectionEvent(canvasHandler, Collections.emptyList())); verify(ssp, times(1)).moveShapeToTop(); } |
### Question:
LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { @Override protected void onSelect(final Collection<String> uuids) { super.onSelect(uuids); final Collection<ShapeView> shapeViews = uuids.stream() .map(uuid -> getCanvasHandler().getCanvas().getShape(uuid)) .filter(Objects::nonNull) .map(org.kie.workbench.common.stunner.core.client.shape.Shape::getShapeView) .collect(Collectors.toList()); shapeViews.stream() .filter(view -> view instanceof WiresShapeView) .forEach(view -> getSelectionManager().getSelectedItems().add((WiresShape) view)); shapeViews.stream() .filter(view -> view instanceof WiresConnectorView) .forEach(view -> getSelectionManager().getSelectedItems().add((WiresConnector) view)); } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); }### Answer:
@Test public void testOnSelectEvent() { final SelectionManager.SelectedItems selectedItems = mock(SelectionManager.SelectedItems.class); when(selectionManager.getSelectedItems()).thenReturn(selectedItems); tested.init(canvasHandler); tested.register(element); tested.onSelect(Collections.singletonList(ELEMENT_UUID)); verify(selectedItems, times(1)).add(eq(shapeView)); verify(selectionControl, never()).clearSelection(); } |
### Question:
LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { protected void onShapeLocationsChanged(@Observes ShapeLocationsChangedEvent event) { if (isSameCanvas(event.getCanvasHandler()) && areSelected(event.getUuids())) { rebuildSelectionArea(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); }### Answer:
@Test public void testOnShapeLocationsChanged() { when(shapeLocationsChangedEvent.getCanvasHandler()).thenReturn(mock(CanvasHandler.class)); tested.onShapeLocationsChanged(shapeLocationsChangedEvent); verify(selectedItems, never()).rebuildBoundingBox(); verify(selectionManager, never()).drawSelectionShape(eq(MIN_WIDTH), eq(MIN_HEIGHT), eq(MAX_WIDTH), eq(MAX_HEIGHT), eq(overLayer)); when(shapeLocationsChangedEvent.getCanvasHandler()).thenReturn(canvasHandler); when(shapeLocationsChangedEvent.getUuids()).thenReturn(new ArrayList<>()); tested.onShapeLocationsChanged(shapeLocationsChangedEvent); verify(selectedItems, never()).rebuildBoundingBox(); verify(selectionManager, never()).drawSelectionShape(eq(MIN_WIDTH), eq(MIN_HEIGHT), eq(MAX_WIDTH), eq(MAX_HEIGHT), eq(overLayer)); when(shapeLocationsChangedEvent.getCanvasHandler()).thenReturn(canvasHandler); List<String> selectedUUIds = new ArrayList<>(); selectedUUIds.add("ELEMENT"); when(shapeLocationsChangedEvent.getUuids()).thenReturn(selectedUUIds); when(tested.getSelectedItems()).thenReturn(selectedUUIds); when(delegateShapeProvider.getShape()).thenReturn(mock(com.ait.lienzo.client.core.shape.Shape.class)); when(selectionManager.getSelectedItems()).thenReturn(selectedItems); when(selectedItems.getBoundingBox()).thenReturn(new BoundingBox(MIN_WIDTH, MIN_HEIGHT, MAX_WIDTH, MAX_HEIGHT)); when(shapeLocationsChangedEvent.getCanvasHandler()).thenReturn(canvasHandler); tested.onShapeLocationsChanged(shapeLocationsChangedEvent); verify(selectedItems, times(1)).rebuildBoundingBox(); verify(selectionManager, times(1)).drawSelectionShapeForSelection(); } |
### Question:
LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { @Override protected void onClearSelection() { super.onClearSelection(); if (Objects.nonNull(getSelectionControl().getCanvasHandler())) { getSelectionManager().clearSelection(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); }### Answer:
@Test public void testOnClearSelectionEvent() { tested.init(canvasHandler); tested.onClearSelection(); verify(selectionControl, never()).clearSelection(); verify(selectionManager, times(1)).clearSelection(); } |
### Question:
LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { @Override protected void onDestroy() { getSelectionManager().destroy(); selectionShapeProvider.destroy(); super.onDestroy(); } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(tested).onDestroy(); verify(selectionManager).destroy(); verify(selectionShapeProvider).destroy(); } |
### Question:
ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { @Override public boolean allow(final Element parent, final Node[] children) { return evaluate(parent, children, command -> getCommandManager().allow(getCanvasHandler(), command), true); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); }### Answer:
@Test public void testAllow() { tested.init(canvasHandler); final boolean allow = tested.allow(parent, new Node[]{candidate}); assertTrue(allow); verify(commandManager, times(1)).allow(eq(canvasHandler), eq(updateChildrenCommand)); assertEquals(parent, updateChildrenCommand.getParent()); assertEquals(candidate, updateChildrenCommand.getCandidates().iterator().next()); verify(highlight, times(1)).unhighLight(); } |
### Question:
ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { @Override public boolean accept(final Element parent, final Node[] children) { return evaluate(parent, children, command -> getCommandManager().execute(getCanvasHandler(), command), false); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); }### Answer:
@Test public void testAccept() { tested.init(canvasHandler); final boolean accept = tested.accept(parent, new Node[]{candidate}); assertTrue(accept); verify(commandManager, times(1)).execute(eq(canvasHandler), eq(updateChildrenCommand)); assertEquals(parent, updateChildrenCommand.getParent()); assertEquals(candidate, updateChildrenCommand.getCandidates().iterator().next()); verify(highlight, times(1)).unhighLight(); } |
### Question:
ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); }### Answer:
@Test public void testIsSameParent() { Node parent = new NodeImpl<>("parentUUID"); Node child1 = new NodeImpl<>("child1"); setAsChild(parent, child1); Node child2 = new NodeImpl<>("child2"); setAsChild(parent, child2); Node[] children = {child1, child2}; boolean isSameParent = ContainmentAcceptorControlImpl.areInSameParent(parent, children); assertTrue(isSameParent); }
@Test public void testIsNotSameParent1() { Node parent = new NodeImpl<>("parentUUID"); Node child1 = new NodeImpl<>("child1"); Node child2 = new NodeImpl<>("child2"); setAsChild(parent, child2); Node[] children = {child1, child2}; boolean isSameParent = ContainmentAcceptorControlImpl.areInSameParent(parent, children); assertFalse(isSameParent); }
@Test public void testIsNotSameParent2() { Node parent = new NodeImpl<>("parentUUID"); Node child1 = new NodeImpl<>("child1"); setAsChild(parent, child1); Node child2 = new NodeImpl<>("child2"); Node[] children = {child1, child2}; boolean isSameParent = ContainmentAcceptorControlImpl.areInSameParent(parent, children); assertFalse(isSameParent); }
@Test public void testIsNotSameParentAll() { Node parent = new NodeImpl<>("parentUUID"); Node child1 = new NodeImpl<>("child1"); Node child2 = new NodeImpl<>("child2"); Node[] children = {child1, child2}; boolean isSameParent = ContainmentAcceptorControlImpl.areInSameParent(parent, children); assertFalse(isSameParent); }
@Test public void testIsNotSameParentNull() { Node parent = new NodeImpl<>("parentUUID"); Node child1 = new NodeImpl<>("child1"); setAsChild(parent, child1); Node child2 = new NodeImpl<>("child2"); setAsChild(parent, child2); Node[] children = {child1, child2}; boolean isSameParent = ContainmentAcceptorControlImpl.areInSameParent(null, children); assertFalse(isSameParent); } |
### Question:
ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element)) { final Canvas<?> canvas = canvasHandler.getCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); if (supportsResize(shape)) { registerResizeHandlers(element, shape); } } } protected ResizeControlImpl(); @Inject ResizeControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> resize(final Element element,
final double width,
final double height); @Override void setCommandManagerProvider(final RequiresCommandManager.CommandManagerProvider<AbstractCanvasHandler> provider); }### Answer:
@Test public void testRegister() { tested.init(canvasHandler); assertFalse(tested.isRegistered(element)); tested.register(element); verify(shapeView, times(1)).supports(eq(ViewEventType.RESIZE)); verify(shapeView, times(1)).addHandler(eq(ViewEventType.RESIZE), any(ResizeHandler.class)); assertTrue(tested.isRegistered(element)); }
@Test @SuppressWarnings("unchecked") public void testDeregister() { tested.init(canvasHandler); tested.register(element); tested.deregister(element); verify(shapeView, times(1)).removeHandler(any(ViewHandler.class)); assertFalse(tested.isRegistered(element)); } |
### Question:
ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> resize(final Element element, final double width, final double height) { return doResize(element, width, height); } protected ResizeControlImpl(); @Inject ResizeControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> resize(final Element element,
final double width,
final double height); @Override void setCommandManagerProvider(final RequiresCommandManager.CommandManagerProvider<AbstractCanvasHandler> provider); }### Answer:
@Test @SuppressWarnings("unchecked") public void testResize() { tested.init(canvasHandler); assertFalse(tested.isRegistered(element)); tested.register(element); verify(shapeView, times(1)).supports(eq(ViewEventType.RESIZE)); ArgumentCaptor<ResizeHandler> resizeHandlerArgumentCaptor = ArgumentCaptor.forClass(ResizeHandler.class); verify(shapeView, times(1)).addHandler(eq(ViewEventType.RESIZE), resizeHandlerArgumentCaptor.capture()); final CanvasCommand expectedCommand = mock(CanvasCommand.class); doAnswer(invocationOnMock -> expectedCommand).when(canvasCommandFactory).resize(eq(element), any(BoundingBox.class)); ResizeHandler resizeHandler = resizeHandlerArgumentCaptor.getValue(); double x = 121.45d; double y = 23.456d; double width = 100d; double height = 200d; ResizeEvent event = new ResizeEvent(x, y, x, y, width, height); resizeHandler.end(event); ArgumentCaptor<CanvasCommand> commandArgumentCaptor = ArgumentCaptor.forClass(CanvasCommand.class); verify(commandManager, times(1)).execute(eq(canvasHandler), commandArgumentCaptor.capture()); CanvasCommand command = commandArgumentCaptor.getValue(); assertNotNull(command); assertEquals(expectedCommand, command); } |
### Question:
ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @SuppressWarnings("unchecked") protected void onCanvasSelectionEvent(@Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (event.getIdentifiers().size() == 1) { final String uuid = event.getIdentifiers().iterator().next(); if (isSameCanvas(event) && isRegistered(uuid)) { hideALLCPs(); final HasControlPoints<?> hasControlPoints = getControlPointsInstance(uuid); if (!hasControlPoints.areControlsVisible()) { showCPs(hasControlPoints); } } } else if (event.getIdentifiers().size() > 1){ hideALLCPs(); } } protected ResizeControlImpl(); @Inject ResizeControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> resize(final Element element,
final double width,
final double height); @Override void setCommandManagerProvider(final RequiresCommandManager.CommandManagerProvider<AbstractCanvasHandler> provider); }### Answer:
@Test public void testOnCanvasSelectionEvent() { tested.onCanvasSelectionEvent(elementsSelectedEvent); verify(elementsSelectedEvent, times(2)).getIdentifiers(); } |
### Question:
LienzoSelectionControl extends AbstractSelectionControl<H> { Map<String, ViewHandler<?>> getHandlers() { return handlers; } @Inject LienzoSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); }### Answer:
@Test public void testRegisterAndClick() { tested.init(canvasHandler); tested.register(element); verify(selectionControl, times(1)).register(eq(element)); ArgumentCaptor<MouseClickHandler> clickHandlerCaptor = ArgumentCaptor.forClass(MouseClickHandler.class); verify(shapeViewHandlers, times(1)).supports(eq(ViewEventType.MOUSE_CLICK)); verify(shapeViewHandlers, times(1)).addHandler(eq(ViewEventType.MOUSE_CLICK), clickHandlerCaptor.capture()); final MouseClickHandler clickHandler = clickHandlerCaptor.getValue(); assertEquals(clickHandler, tested.getHandlers().get(ELEMENT_UUID)); MouseClickEvent event = mock(MouseClickEvent.class); when(event.isButtonLeft()).thenReturn(true); clickHandler.handle(event); verify(selectionControl, times(1)).select(eq(element.getUUID())); } |
### Question:
LienzoSelectionControl extends AbstractSelectionControl<H> { void singleSelect(final Element element) { if (!getSelectedItems().isEmpty()) { clearSelection(); } select(element.getUUID()); } @Inject LienzoSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); }### Answer:
@Test public void testSelectionIsSingle() { when(selectionControl.getSelectedItems()).thenReturn(Collections.singletonList(ELEMENT_UUID)); tested.init(canvasHandler); tested.register(element); tested.singleSelect(element); verify(selectionControl, times(1)).clearSelection(); verify(selectionControl, times(1)).select(eq(element.getUUID())); }
@Test public void testClearSelection() { tested.init(canvasHandler); tested.register(element); tested.singleSelect(element); tested.clearSelection(); verify(selectionControl, times(1)).clearSelection(); } |
### Question:
LienzoSelectionControl extends AbstractSelectionControl<H> { protected void deregister(final String uuid) { final Shape shape = getSelectionControl().getCanvas().getShape(uuid); final ViewHandler<?> handler = handlers.get(uuid); doDeregisterHandler(shape, handler); } @Inject LienzoSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); }### Answer:
@Test @SuppressWarnings("unchecked") public void testDeregister() { tested.init(canvasHandler); tested.register(element); tested.deregister(element); verify(selectionControl, times(1)).deregister(eq(element)); verify(shapeViewHandlers, times(1)).removeHandler(any(ViewHandler.class)); assertTrue(tested.getHandlers().isEmpty()); } |
### Question:
LienzoCanvas extends AbstractCanvas<V> { public AbstractCanvas<V> initialize(final CanvasPanel panel, final CanvasSettings settings) { eventHandlerManager = new ViewEventHandlerManager(getView().getLayer().getLienzoLayer(), SUPPORTED_EVENT_TYPES); return initialize(panel, settings, eventHandlerManager); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Optional<Shape> getShapeAt(final double x,
final double y); @Override void onAfterDraw(final Command callback); @Override void focus(); @Override boolean supports(final ViewEventType type); @Override AbstractCanvas<V> addHandler(final ViewEventType type,
final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> removeHandler(final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> enableHandlers(); @Override AbstractCanvas<V> disableHandlers(); @Override Shape<?> getAttachableShape(); @Override void destroy(); }### Answer:
@Test public void testInitialize() { CanvasPanel panel = mock(CanvasPanel.class); CanvasSettings settings = mock(CanvasSettings.class); when(settings.isHiDPIEnabled()).thenReturn(true); assertEquals(tested, tested.initialize(panel, settings)); assertTrue(LienzoCore.get().isHidpiEnabled()); assertNotNull(tested.getEventHandlerManager()); verify(view, times(1)).initialize(eq(panel), eq(settings)); } |
### Question:
LienzoCanvas extends AbstractCanvas<V> { @Override public Optional<Shape> getShapeAt(final double x, final double y) { final LienzoLayer lienzoLayer = getView().getLayer(); final String uuid = LienzoLayerUtils.getUUID_At(lienzoLayer, x, y); return Optional.ofNullable(getShape(uuid)); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Optional<Shape> getShapeAt(final double x,
final double y); @Override void onAfterDraw(final Command callback); @Override void focus(); @Override boolean supports(final ViewEventType type); @Override AbstractCanvas<V> addHandler(final ViewEventType type,
final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> removeHandler(final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> enableHandlers(); @Override AbstractCanvas<V> disableHandlers(); @Override Shape<?> getAttachableShape(); @Override void destroy(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testGetShapeAt() { double x = 10; double y = 33; com.ait.lienzo.client.core.shape.Shape lienzoShape = mock(com.ait.lienzo.client.core.shape.Shape.class); WiresUtils.UserData userData = new WiresUtils.UserData("uuid1", "group1"); when(lienzoShape.getUserData()).thenReturn(userData); when(layer.findShapeAtPoint(eq(10), eq(33))).thenReturn(lienzoShape); Shape stunnerShape = mock(Shape.class); when(tested.getShape(eq("uuid1"))).thenReturn(stunnerShape); Optional<Shape> shape = tested.getShapeAt(x, y); assertTrue(shape.isPresent()); assertEquals(stunnerShape, shape.get()); } |
### Question:
LienzoCanvas extends AbstractCanvas<V> { @Override public void onAfterDraw(final Command callback) { getView().getLayer().onAfterDraw(callback); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Optional<Shape> getShapeAt(final double x,
final double y); @Override void onAfterDraw(final Command callback); @Override void focus(); @Override boolean supports(final ViewEventType type); @Override AbstractCanvas<V> addHandler(final ViewEventType type,
final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> removeHandler(final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> enableHandlers(); @Override AbstractCanvas<V> disableHandlers(); @Override Shape<?> getAttachableShape(); @Override void destroy(); }### Answer:
@Test public void testOnAfterDraw() { Command callback = mock(Command.class); tested.onAfterDraw(callback); verify(lienzoLayer, times(1)).onAfterDraw(eq(callback)); } |
### Question:
LienzoCanvas extends AbstractCanvas<V> { @Override public void focus() { getView().getLienzoPanel().focus(); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Optional<Shape> getShapeAt(final double x,
final double y); @Override void onAfterDraw(final Command callback); @Override void focus(); @Override boolean supports(final ViewEventType type); @Override AbstractCanvas<V> addHandler(final ViewEventType type,
final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> removeHandler(final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> enableHandlers(); @Override AbstractCanvas<V> disableHandlers(); @Override Shape<?> getAttachableShape(); @Override void destroy(); }### Answer:
@Test public void testFocus() { LienzoPanel panel = mock(LienzoPanel.class); when(view.getLienzoPanel()).thenReturn(panel); tested.focus(); verify(panel, times(1)).focus(); } |
### Question:
LienzoCanvas extends AbstractCanvas<V> { @Override public void destroy() { if (null != eventHandlerManager) { eventHandlerManager.destroy(); eventHandlerManager = null; } super.destroy(); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Optional<Shape> getShapeAt(final double x,
final double y); @Override void onAfterDraw(final Command callback); @Override void focus(); @Override boolean supports(final ViewEventType type); @Override AbstractCanvas<V> addHandler(final ViewEventType type,
final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> removeHandler(final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> enableHandlers(); @Override AbstractCanvas<V> disableHandlers(); @Override Shape<?> getAttachableShape(); @Override void destroy(); }### Answer:
@Test public void testDestroy() { CanvasPanel panel = mock(CanvasPanel.class); CanvasSettings settings = mock(CanvasSettings.class); ViewEventHandlerManager eventHandler = mock(ViewEventHandlerManager.class); tested.initialize(panel, settings, eventHandler); tested.destroy(); verify(eventHandler, times(1)).destroy(); verify(view, times(1)).destroy(); } |
### Question:
LienzoCanvasCommandFactory extends DefaultCanvasCommandFactory { @Override public CanvasCommand<AbstractCanvasHandler> resize(final Element<? extends View<?>> element, final BoundingBox boundingBox) { return new LienzoResizeNodeCommand(element, boundingBox); } protected LienzoCanvasCommandFactory(); @Inject LienzoCanvasCommandFactory(final @Any ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessors,
final @Any ManagedInstance<ViewTraverseProcessor> viewTraverseProcessors); @Override CanvasCommand<AbstractCanvasHandler> resize(final Element<? extends View<?>> element,
final BoundingBox boundingBox); }### Answer:
@Test @SuppressWarnings("unchecked") public void testCreateResizeCommand() { Element element = mock(Element.class); BoundingBox boundingBox = new BoundingBox(0, 0, 1, 2); final CanvasCommand<AbstractCanvasHandler> command = tested.resize(element, boundingBox); assertNotNull(command); assertTrue(command instanceof LienzoResizeNodeCommand); LienzoResizeNodeCommand lienzoCommand = (LienzoResizeNodeCommand) command; assertEquals(element, lienzoCommand.getCandidate()); assertEquals(boundingBox, lienzoCommand.getBoundingBox()); } |
### Question:
WiresCanvasView extends LienzoCanvasView<WiresLayer> { public void use(final WiresManager wiresManager) { layer.use(wiresManager); } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); }### Answer:
@Test public void testUseWiresManager() { WiresManager wiresManager = mock(WiresManager.class); tested.use(wiresManager); verify(wiresLayer, times(1)).use(eq(wiresManager)); } |
### Question:
WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.add((WiresShape) shape); } else if (WiresUtils.isWiresConnector(shape)) { layer.add((WiresConnector) shape); } else { return super.add(shape); } return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); }### Answer:
@Test public void testAdd() { WiresShapeView shapeView = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); tested.add(shapeView); verify(wiresLayer, times(1)).add(eq(shapeView)); } |
### Question:
WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.delete((WiresShape) shape); } else if (WiresUtils.isWiresConnector(shape)) { layer.delete((WiresConnector) shape); } else { return super.delete(shape); } return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); }### Answer:
@Test public void testDelete() { WiresShapeView shapeView = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); tested.delete(shapeView); verify(wiresLayer, times(1)).delete(eq(shapeView)); } |
### Question:
WiresCanvasView extends LienzoCanvasView<WiresLayer> { public LienzoCanvasView addRoot(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.add(((WiresShape) shape).getGroup()); } else if (WiresUtils.isWiresConnector(shape)) { layer.add(((WiresConnector) shape).getGroup()); } else { return super.add(shape); } return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); }### Answer:
@Test public void testAddRoot() { WiresShapeView shapeView = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); tested.addRoot(shapeView); verify(wiresLayer, times(1)).add(eq(shapeView.getGroup())); } |
### Question:
WiresCanvasView extends LienzoCanvasView<WiresLayer> { public LienzoCanvasView deleteRoot(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.delete(((WiresShape) shape).getGroup()); } else if (WiresUtils.isWiresConnector(shape)) { layer.delete(((WiresConnector) shape).getGroup()); } else { return super.delete(shape); } return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); }### Answer:
@Test public void testDeleteRoot() { WiresShapeView shapeView = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); tested.deleteRoot(shapeView); verify(wiresLayer, times(1)).delete(eq(shapeView.getGroup())); } |
### Question:
WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView addChild(final ShapeView<?> parent, final ShapeView<?> child) { final WiresContainer parentShape = (WiresContainer) parent; final WiresShape childShape = (WiresShape) child; layer.addChild(parentShape, childShape); childShape.shapeMoved(); return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); }### Answer:
@Test public void testAddChild() { WiresShapeView parent = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); WiresShapeView child = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); tested.addChild(parent, child); verify(wiresLayer, times(1)).addChild(eq(parent), eq(child)); } |
### Question:
WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView deleteChild(final ShapeView<?> parent, final ShapeView<?> child) { final WiresContainer parentShape = (WiresContainer) parent; final WiresShape childShape = (WiresShape) child; layer.deleteChild(parentShape, childShape); childShape.shapeMoved(); return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); }### Answer:
@Test public void testDeleteChild() { WiresShapeView parent = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); WiresShapeView child = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); tested.deleteChild(parent, child); verify(wiresLayer, times(1)).deleteChild(eq(parent), eq(child)); } |
### Question:
WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView dock(final ShapeView<?> parent, final ShapeView<?> child) { final WiresContainer parentShape = (WiresContainer) parent; final WiresShape childShape = (WiresShape) child; layer.dock(parentShape, childShape); childShape.shapeMoved(); return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); }### Answer:
@Test public void testDock() { WiresShapeView parent = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); WiresShapeView child = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); tested.dock(parent, child); verify(wiresLayer, times(1)).dock(eq(parent), eq(child)); } |
### Question:
WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView undock(final ShapeView<?> childParent, final ShapeView<?> child) { final WiresShape childShape = (WiresShape) child; layer.undock(childShape); childShape.shapeMoved(); return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); }### Answer:
@Test public void testUnDock() { WiresShapeView parent = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); WiresShapeView child = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); tested.undock(parent, child); verify(wiresLayer, times(1)).undock(eq(child)); } |
### Question:
WiresCanvas extends LienzoCanvas<WiresCanvasView> { @Override public WiresCanvasView getView() { return view; } @Inject WiresCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent,
final @Default WiresManagerFactory wiresManagerFactory,
final WiresCanvasView view); @Override AbstractCanvas<WiresCanvasView> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override WiresCanvasView getView(); WiresManager getWiresManager(); static final String WIRES_CANVAS_GROUP_ID; }### Answer:
@Test public void testGetView() { assertEquals(view, tested.getView()); } |
### Question:
WiresCanvas extends LienzoCanvas<WiresCanvasView> { @Override public AbstractCanvas<WiresCanvasView> initialize(final CanvasPanel panel, final CanvasSettings settings) { super.initialize(panel, settings); final WiresLayer layer = getView().getLayer(); wiresManager = wiresManagerFactory.newWiresManager(layer.getLienzoLayer()); wiresManager.setSpliceEnabled(false); wiresManager.setLocationAcceptor(ILocationAcceptor.NONE); wiresManager.setContainmentAcceptor(IContainmentAcceptor.NONE); wiresManager.setDockingAcceptor(IDockingAcceptor.NONE); wiresManager.setConnectionAcceptor(IConnectionAcceptor.NONE); wiresManager.setControlPointsAcceptor(IControlPointsAcceptor.NONE); view.use(wiresManager); return this; } @Inject WiresCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent,
final @Default WiresManagerFactory wiresManagerFactory,
final WiresCanvasView view); @Override AbstractCanvas<WiresCanvasView> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override WiresCanvasView getView(); WiresManager getWiresManager(); static final String WIRES_CANVAS_GROUP_ID; }### Answer:
@Test public void testInitialize() { CanvasPanel panel = mock(CanvasPanel.class); CanvasSettings settings = mock(CanvasSettings.class); assertEquals(tested, tested.initialize(panel, settings)); verify(wiresManager, times(1)).setSpliceEnabled(eq(false)); verify(wiresManager, times(1)).setLocationAcceptor(eq(ILocationAcceptor.NONE)); verify(wiresManager, times(1)).setContainmentAcceptor(eq(IContainmentAcceptor.NONE)); verify(wiresManager, times(1)).setDockingAcceptor(eq(IDockingAcceptor.NONE)); verify(wiresManager, times(1)).setConnectionAcceptor(eq(IConnectionAcceptor.NONE)); verify(wiresManager, times(1)).setControlPointsAcceptor(eq(IControlPointsAcceptor.NONE)); verify(view, times(1)).use(eq(wiresManager)); verify(view, times(1)).initialize(eq(panel), eq(settings)); assertEquals(wiresManager, tested.getWiresManager()); } |
### Question:
WiresCanvas extends LienzoCanvas<WiresCanvasView> { @Override protected void addChild(final Shape shape) { getView().addRoot(shape.getShapeView()); } @Inject WiresCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent,
final @Default WiresManagerFactory wiresManagerFactory,
final WiresCanvasView view); @Override AbstractCanvas<WiresCanvasView> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override WiresCanvasView getView(); WiresManager getWiresManager(); static final String WIRES_CANVAS_GROUP_ID; }### Answer:
@Test public void testAddChild() { Shape shape = mock(Shape.class); ShapeView shapeView = mock(ShapeView.class); when(shape.getShapeView()).thenReturn(shapeView); tested.addChild(shape); verify(view, times(1)).addRoot(eq(shapeView)); } |
### Question:
WiresCanvas extends LienzoCanvas<WiresCanvasView> { @Override protected void deleteChild(final Shape shape) { getView().deleteRoot(shape.getShapeView()); } @Inject WiresCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent,
final @Default WiresManagerFactory wiresManagerFactory,
final WiresCanvasView view); @Override AbstractCanvas<WiresCanvasView> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override WiresCanvasView getView(); WiresManager getWiresManager(); static final String WIRES_CANVAS_GROUP_ID; }### Answer:
@Test public void testDeleteChild() { Shape shape = mock(Shape.class); ShapeView shapeView = mock(ShapeView.class); when(shape.getShapeView()).thenReturn(shapeView); tested.deleteChild(shape); verify(view, times(1)).deleteRoot(eq(shapeView)); } |
### Question:
WiresLayer extends LienzoLayer { public LienzoLayer add(final WiresShape wiresShape) { if (contains(wiresShape)) { LOGGER.log(Level.WARNING, "Cannot add a WiresShape into the WiresLayer twice!"); } else { wiresManager.register(wiresShape); wiresManager.getMagnetManager().createMagnets(wiresShape, MAGNET_CARDINALS); WiresUtils.assertShapeGroup(wiresShape.getGroup(), WiresCanvas.WIRES_CANVAS_GROUP_ID); } return this; } WiresLayer use(final WiresManager wiresManager); LienzoLayer add(final WiresShape wiresShape); LienzoLayer add(final WiresConnector wiresConnector); LienzoLayer delete(final WiresShape wiresShape); LienzoLayer delete(final WiresConnector wiresConnector); WiresLayer addChild(final WiresContainer parent,
final WiresShape child); WiresLayer deleteChild(final WiresContainer parent,
final WiresShape child); WiresLayer dock(final WiresContainer parent,
final WiresShape child); WiresLayer undock(final WiresShape child); WiresManager getWiresManager(); @Override void destroy(); }### Answer:
@Test public void testAddShape() { tested.add(shape); verify(wiresManager, times(1)).register(eq(shape)); verify(magnetManager, times(1)).createMagnets(eq(shape), eq(WiresLayer.MAGNET_CARDINALS)); }
@Test public void testAddShapeTwice() { when(wiresManager.getShape(eq(SHAPE_UUID))).thenReturn(shape); tested.add(shape); verify(wiresManager, never()).register(eq(shape)); verify(magnetManager, never()).createMagnets(eq(shape), eq(WiresLayer.MAGNET_CARDINALS)); }
@Test public void testAddconnector() { tested.add(connector); verify(wiresManager, times(1)).register(eq(connector)); } |
### Question:
WiresLayer extends LienzoLayer { public LienzoLayer delete(final WiresShape wiresShape) { wiresManager.deregister(wiresShape); return this; } WiresLayer use(final WiresManager wiresManager); LienzoLayer add(final WiresShape wiresShape); LienzoLayer add(final WiresConnector wiresConnector); LienzoLayer delete(final WiresShape wiresShape); LienzoLayer delete(final WiresConnector wiresConnector); WiresLayer addChild(final WiresContainer parent,
final WiresShape child); WiresLayer deleteChild(final WiresContainer parent,
final WiresShape child); WiresLayer dock(final WiresContainer parent,
final WiresShape child); WiresLayer undock(final WiresShape child); WiresManager getWiresManager(); @Override void destroy(); }### Answer:
@Test public void testDeleteShape() { tested.delete(shape); verify(wiresManager, times(1)).deregister(eq(shape)); }
@Test public void testDeleteConnector() { tested.delete(connector); verify(wiresManager, times(1)).deregister(eq(connector)); } |
### Question:
WiresLayer extends LienzoLayer { public WiresLayer addChild(final WiresContainer parent, final WiresShape child) { parent.add(child); return this; } WiresLayer use(final WiresManager wiresManager); LienzoLayer add(final WiresShape wiresShape); LienzoLayer add(final WiresConnector wiresConnector); LienzoLayer delete(final WiresShape wiresShape); LienzoLayer delete(final WiresConnector wiresConnector); WiresLayer addChild(final WiresContainer parent,
final WiresShape child); WiresLayer deleteChild(final WiresContainer parent,
final WiresShape child); WiresLayer dock(final WiresContainer parent,
final WiresShape child); WiresLayer undock(final WiresShape child); WiresManager getWiresManager(); @Override void destroy(); }### Answer:
@Test public void testAddChild() { WiresShape parent = mock(WiresShape.class); tested.addChild(parent, shape); verify(parent, times(1)).add(eq(shape)); } |
### Question:
WiresLayer extends LienzoLayer { public WiresLayer deleteChild(final WiresContainer parent, final WiresShape child) { parent.remove(child); return this; } WiresLayer use(final WiresManager wiresManager); LienzoLayer add(final WiresShape wiresShape); LienzoLayer add(final WiresConnector wiresConnector); LienzoLayer delete(final WiresShape wiresShape); LienzoLayer delete(final WiresConnector wiresConnector); WiresLayer addChild(final WiresContainer parent,
final WiresShape child); WiresLayer deleteChild(final WiresContainer parent,
final WiresShape child); WiresLayer dock(final WiresContainer parent,
final WiresShape child); WiresLayer undock(final WiresShape child); WiresManager getWiresManager(); @Override void destroy(); }### Answer:
@Test public void testDeleteChild() { WiresShape parent = mock(WiresShape.class); tested.deleteChild(parent, shape); verify(parent, times(1)).remove(eq(shape)); } |
### Question:
WiresLayer extends LienzoLayer { public WiresLayer dock(final WiresContainer parent, final WiresShape child) { final WiresDockingControl dockingControl = child.getControl().getDockingControl(); dockingControl.dock(parent); final Point2D candidateLocation = dockingControl.getCandidateLocation(); if (null != candidateLocation) { child.setLocation(candidateLocation); } return this; } WiresLayer use(final WiresManager wiresManager); LienzoLayer add(final WiresShape wiresShape); LienzoLayer add(final WiresConnector wiresConnector); LienzoLayer delete(final WiresShape wiresShape); LienzoLayer delete(final WiresConnector wiresConnector); WiresLayer addChild(final WiresContainer parent,
final WiresShape child); WiresLayer deleteChild(final WiresContainer parent,
final WiresShape child); WiresLayer dock(final WiresContainer parent,
final WiresShape child); WiresLayer undock(final WiresShape child); WiresManager getWiresManager(); @Override void destroy(); }### Answer:
@Test public void testDock() { WiresShapeControl control = mock(WiresShapeControl.class); WiresDockingControl dockingControl = mock(WiresDockingControl.class); when(control.getDockingControl()).thenReturn(dockingControl); when(shape.getControl()).thenReturn(control); Point2D location = new Point2D(1, 1); when(dockingControl.getCandidateLocation()).thenReturn(location); WiresShape parent = mock(WiresShape.class); tested.dock(parent, shape); verify(dockingControl, times(1)).dock(eq(parent)); verify(shape, times(1)).setLocation(eq(location)); }
@Test public void testDockButNoContext() { WiresShapeControl control = mock(WiresShapeControl.class); WiresDockingControl dockingControl = mock(WiresDockingControl.class); when(control.getDockingControl()).thenReturn(dockingControl); when(shape.getControl()).thenReturn(control); when(dockingControl.getCandidateLocation()).thenReturn(null); WiresShape parent = mock(WiresShape.class); tested.dock(parent, shape); verify(dockingControl, times(1)).dock(eq(parent)); verify(shape, never()).setLocation(any(Point2D.class)); } |
### Question:
WiresLayer extends LienzoLayer { public WiresLayer undock(final WiresShape child) { child.getControl().getDockingControl().undock(); return this; } WiresLayer use(final WiresManager wiresManager); LienzoLayer add(final WiresShape wiresShape); LienzoLayer add(final WiresConnector wiresConnector); LienzoLayer delete(final WiresShape wiresShape); LienzoLayer delete(final WiresConnector wiresConnector); WiresLayer addChild(final WiresContainer parent,
final WiresShape child); WiresLayer deleteChild(final WiresContainer parent,
final WiresShape child); WiresLayer dock(final WiresContainer parent,
final WiresShape child); WiresLayer undock(final WiresShape child); WiresManager getWiresManager(); @Override void destroy(); }### Answer:
@Test public void testUnDock() { WiresShape child = mock(WiresShape.class); WiresShapeControl control = mock(WiresShapeControl.class); WiresDockingControl dockingControl = mock(WiresDockingControl.class); when(control.getDockingControl()).thenReturn(dockingControl); when(child.getControl()).thenReturn(control); tested.undock(child); verify(dockingControl, times(1)).undock(); } |
### Question:
WiresUtils { public static boolean isWiresLayer(final WiresContainer wiresShape) { return null != wiresShape && wiresShape instanceof WiresLayer; } static Point2D getAbsolute(final IDrawable<?> shape); static Node getNode(final AbstractCanvasHandler canvasHandler,
final WiresContainer shape); static Node getNode(final AbstractCanvasHandler canvasHandler,
final WiresMagnet magnet); static Edge getEdge(final AbstractCanvasHandler canvasHandler,
final WiresConnector connector); static boolean isWiresShape(final ShapeView<?> shapeView); static boolean isWiresContainer(final ShapeView<?> shapeView); static boolean isWiresConnector(final ShapeView<?> shapeView); static boolean isWiresShape(final WiresContainer wiresShape); static boolean isWiresLayer(final WiresContainer wiresShape); static void assertShapeUUID(final IDrawable<?> shape,
final String uuid); static String getShapeUUID(final IDrawable<?> shape); static void assertShapeGroup(final IDrawable<?> shape,
final String group); static String getShapeGroup(final IDrawable<?> shape); }### Answer:
@Test public void isWiresLayerWhenWiresLayer() { final Layer l = new Layer(); final WiresLayer wl = new WiresLayer(l); assertTrue(WiresUtils.isWiresLayer(wl)); }
@Test public void isWiresLayerWhenWiresShape() { final WiresShape ws = new WiresShape(new MultiPath()); assertFalse(WiresUtils.isWiresLayer(ws)); } |
### Question:
WiresUtils { public static boolean isWiresShape(final ShapeView<?> shapeView) { return shapeView instanceof WiresShape; } static Point2D getAbsolute(final IDrawable<?> shape); static Node getNode(final AbstractCanvasHandler canvasHandler,
final WiresContainer shape); static Node getNode(final AbstractCanvasHandler canvasHandler,
final WiresMagnet magnet); static Edge getEdge(final AbstractCanvasHandler canvasHandler,
final WiresConnector connector); static boolean isWiresShape(final ShapeView<?> shapeView); static boolean isWiresContainer(final ShapeView<?> shapeView); static boolean isWiresConnector(final ShapeView<?> shapeView); static boolean isWiresShape(final WiresContainer wiresShape); static boolean isWiresLayer(final WiresContainer wiresShape); static void assertShapeUUID(final IDrawable<?> shape,
final String uuid); static String getShapeUUID(final IDrawable<?> shape); static void assertShapeGroup(final IDrawable<?> shape,
final String group); static String getShapeGroup(final IDrawable<?> shape); }### Answer:
@Test public void isWiresShapeWhenWiresContainer() { final WiresContainer wc = new WiresContainer(new Group()); assertFalse(WiresUtils.isWiresShape(wc)); }
@Test public void isWiresShapeWhenWiresLayer() { final Layer l = new Layer(); final WiresLayer wl = new WiresLayer(l); assertTrue(WiresUtils.isWiresShape(wl)); }
@Test public void isWiresShapeWhenUnregisteredWiresShape() { final WiresShape ws = new WiresShape(new MultiPath()); assertFalse(WiresUtils.isWiresShape(ws)); } |
### Question:
LiteralExpressionPropertyConverter { public static LiteralExpression wbFromDMN(final JSITLiteralExpression dmn) { if (Objects.isNull(dmn)) { return null; } final Id id = IdPropertyConverter.wbFromDMN(dmn.getId()); final Description description = DescriptionPropertyConverter.wbFromDMN(dmn.getDescription()); final QName typeRef = QNamePropertyConverter.wbFromDMN(dmn.getTypeRef()); final Text text = new Text(Objects.nonNull(dmn.getText()) ? dmn.getText() : ""); final ExpressionLanguage expressionLanguage = ExpressionLanguagePropertyConverter.wbFromDMN(dmn.getExpressionLanguage()); final ImportedValues importedValues = ImportedValuesConverter.wbFromDMN(dmn.getImportedValues()); final LiteralExpression result = new LiteralExpression(id, description, typeRef, text, importedValues, expressionLanguage); if (Objects.nonNull(importedValues)) { importedValues.setParent(result); } return result; } static LiteralExpression wbFromDMN(final JSITLiteralExpression dmn); static JSITLiteralExpression dmnFromWB(final IsLiteralExpression wb); }### Answer:
@Test public void testWBFromDMN() { when(literalExpression.getId()).thenReturn(UUID); when(literalExpression.getDescription()).thenReturn(DESCRIPTION); when(literalExpression.getTypeRef()).thenReturn(TYPE_REF); when(literalExpression.getText()).thenReturn(TEXT); when(literalExpression.getExpressionLanguage()).thenReturn(EXPRESSION_LANGUAGE); when(literalExpression.getImportedValues()).thenReturn(jsitImportedValues); when(jsitImportedValues.getImportedElement()).thenReturn(IMPORTED_ELEMENT); final LiteralExpression result = LiteralExpressionPropertyConverter.wbFromDMN(literalExpression); assertThat(result.getId().getValue()).isEqualTo(UUID); assertThat(result.getDescription().getValue()).isEqualTo(DESCRIPTION); assertThat(result.getTypeRef().getNamespaceURI()).isEmpty(); assertThat(result.getTypeRef().getLocalPart()).isEqualTo(TYPE_REF); assertThat(result.getText().getValue()).isEqualTo(TEXT); assertThat(result.getExpressionLanguage().getValue()).isEqualTo(EXPRESSION_LANGUAGE); assertThat(result.getImportedValues().getImportedElement()).isEqualTo(IMPORTED_ELEMENT); assertThat(result.getImportedValues().getParent()).isEqualTo(result); } |
### Question:
LiteralExpressionPropertyConverter { public static JSITLiteralExpression dmnFromWB(final IsLiteralExpression wb) { if (Objects.isNull(wb)) { return null; } final JSITLiteralExpression result = LITERAL_EXPRESSION_PROVIDER.make(); result.setId(wb.getId().getValue()); final String description = wb.getDescription().getValue(); if (StringUtils.nonEmpty(description)) { result.setDescription(description); } if (wb instanceof LiteralExpression) { final String expressionLanguage = ((LiteralExpression) wb).getExpressionLanguage().getValue(); if (StringUtils.nonEmpty(expressionLanguage)) { result.setExpressionLanguage(expressionLanguage); } } QNamePropertyConverter.setDMNfromWB(wb.getTypeRef(), result::setTypeRef); result.setText(wb.getText().getValue()); final JSITImportedValues importedValues = ImportedValuesConverter.dmnFromWB(wb.getImportedValues()); if (Objects.nonNull(importedValues)) { result.setImportedValues(importedValues); } return result; } static LiteralExpression wbFromDMN(final JSITLiteralExpression dmn); static JSITLiteralExpression dmnFromWB(final IsLiteralExpression wb); }### Answer:
@Test public void testDMNFromWB() { when(wb.getId()).thenReturn(new Id(UUID)); when(wb.getDescription()).thenReturn(new Description(DESCRIPTION)); when(wb.getTypeRef()).thenReturn(new QName(KIE.getUri(), TYPE_REF, KIE.getPrefix())); when(wb.getText()).thenReturn(new Text(TEXT)); when(wb.getExpressionLanguage()).thenReturn(new ExpressionLanguage(EXPRESSION_LANGUAGE)); final JSITLiteralExpression result = LiteralExpressionPropertyConverter.dmnFromWB(wb); verify(result).setId(UUID); verify(result).setDescription(DESCRIPTION); verify(result).setTypeRef("{" + KIE.getUri() + "}" + TYPE_REF); verify(result).setText(TEXT); verify(result).setExpressionLanguage(EXPRESSION_LANGUAGE); } |
### Question:
OutputClauseLiteralExpressionPropertyConverter { public static OutputClauseLiteralExpression wbFromDMN(final JSITLiteralExpression dmn) { if (Objects.isNull(dmn)) { return new OutputClauseLiteralExpression(); } final Id id = IdPropertyConverter.wbFromDMN(dmn.getId()); final Description description = DescriptionPropertyConverter.wbFromDMN(dmn.getDescription()); final QName typeRef = QNamePropertyConverter.wbFromDMN(dmn.getTypeRef()); final Text text = new Text(dmn.getText()); final ImportedValues importedValues = ImportedValuesConverter.wbFromDMN(dmn.getImportedValues()); final OutputClauseLiteralExpression result = new OutputClauseLiteralExpression(id, description, typeRef, text, importedValues); if (Objects.nonNull(importedValues)) { importedValues.setParent(result); } return result; } static OutputClauseLiteralExpression wbFromDMN(final JSITLiteralExpression dmn); static JSITLiteralExpression dmnFromWB(final OutputClauseLiteralExpression wb); }### Answer:
@Test public void testWBFromDMNWhenNull() { final OutputClauseLiteralExpression wb = OutputClauseLiteralExpressionPropertyConverter.wbFromDMN(null); assertThat(wb).isNotNull(); }
@Test public void testWBFromDMNWhenNonNull() { when(jsitLiteralExpression.getText()).thenReturn(TEXT); final OutputClauseLiteralExpression wb = OutputClauseLiteralExpressionPropertyConverter.wbFromDMN(jsitLiteralExpression); assertThat(wb).isNotNull(); assertThat(wb.getText().getValue()).isEqualTo(TEXT); } |
### Question:
OutputClauseLiteralExpressionPropertyConverter { public static JSITLiteralExpression dmnFromWB(final OutputClauseLiteralExpression wb) { if (Objects.isNull(wb)) { return null; } else if (Objects.isNull(wb.getText())) { return null; } else if (StringUtils.isEmpty(wb.getText().getValue())) { return null; } return LiteralExpressionPropertyConverter.dmnFromWB(wb); } static OutputClauseLiteralExpression wbFromDMN(final JSITLiteralExpression dmn); static JSITLiteralExpression dmnFromWB(final OutputClauseLiteralExpression wb); }### Answer:
@Test public void testDMNFromWBWhenNull() { final JSITLiteralExpression dmn = OutputClauseLiteralExpressionPropertyConverter.dmnFromWB(null); assertThat(dmn).isNull(); }
@Test public void testDMNFromWBWhenTextIsNull() { final OutputClauseLiteralExpression wb = new OutputClauseLiteralExpression(); wb.setText(null); final JSITLiteralExpression dmn = OutputClauseLiteralExpressionPropertyConverter.dmnFromWB(wb); assertThat(dmn).isNull(); }
@Test public void testDMNFromWBWhenNonNullWithEmptyString() { final OutputClauseLiteralExpression wb = new OutputClauseLiteralExpression(); wb.getText().setValue(""); final JSITLiteralExpression dmn = OutputClauseLiteralExpressionPropertyConverter.dmnFromWB(wb); assertThat(dmn).isNull(); }
@Test public void testDMNFromWBWhenNonNullWithNonEmptyString() { final OutputClauseLiteralExpression wb = new OutputClauseLiteralExpression(); wb.getText().setValue(TEXT); final JSITLiteralExpression dmn = OutputClauseLiteralExpressionPropertyConverter.dmnFromWB(wb); assertThat(dmn).isNotNull(); verify(jsitLiteralExpression).setText(TEXT); } |
### Question:
LienzoCanvasExport implements CanvasExport<AbstractCanvasHandler> { @Override public String toImageData(final AbstractCanvasHandler canvasHandler, final CanvasURLExportSettings settings) { final LienzoLayer layer = getLayer(canvasHandler); final int[] bounds = boundsProvider.compute(layer, settings); return LienzoLayerUtils.layerToDataURL(layer, getDataType(settings.getUrlDataType()), bounds[0], bounds[1], bounds[2], bounds[3], BG_COLOR); } LienzoCanvasExport(); LienzoCanvasExport(final BoundsProvider boundsProvider); @Override IContext2D toContext2D(final AbstractCanvasHandler canvasHandler,
final CanvasExportSettings settings); @Override String toImageData(final AbstractCanvasHandler canvasHandler,
final CanvasURLExportSettings settings); static final String BG_COLOR; static final int PADDING; }### Answer:
@Test public void testToJpgImageData() { tested.toImageData(canvasHandler, CanvasURLExportSettings.build(JPG)); verify(context2D, times(1)).setFillColor(eq(LienzoCanvasExport.BG_COLOR)); verify(context2D, times(1)).fillRect(eq(0d), eq(0d), eq(100d), eq(200d)); verify(layer, times(1)).drawWithTransforms(eq(context2D), eq(1d), any(BoundingBox.class)); verify(scratchPad, times(1)).toDataURL(eq(DataURLType.JPG), eq(1d)); verify(scratchPad, times(1)).clear(); }
@Test public void testToPngImageData() { tested.toImageData(canvasHandler, CanvasURLExportSettings.build(PNG)); verify(context2D, times(1)).setFillColor(eq(LienzoCanvasExport.BG_COLOR)); verify(context2D, times(1)).fillRect(eq(0d), eq(0d), eq(100d), eq(200d)); verify(layer, times(1)).drawWithTransforms(eq(context2D), eq(1d), any(BoundingBox.class)); verify(scratchPad, times(1)).toDataURL(eq(DataURLType.PNG), eq(1d)); verify(scratchPad, times(1)).clear(); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.