method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
ActionsToolbox implements Toolbox<ActionsToolbox>,
Iterable<ToolboxAction> { @Override public void destroy() { getView().destroy(); actions.clear(); } ActionsToolbox(final Supplier<AbstractCanvasHandler> canvasHandlerSupplier,
final Element<?> element,
final V view); ActionsToolbox<V> init(); ActionsToolbox add(final ToolboxAction<AbstractCanvasHandler> action); @Override Iterator<ToolboxAction> iterator(); int size(); String getElementUUID(); AbstractCanvasHandler getCanvasHandler(); AbstractCanvas getCanvas(); Shape<?> getShape(); @Override ActionsToolbox show(); @Override ActionsToolbox hide(); @Override void destroy(); @Override void hideAndDestroy(); V getView(); Glyph getGlyph(final ToolboxAction<AbstractCanvasHandler> action); String getTitle(final ToolboxAction<AbstractCanvasHandler> action); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(view, times(1)).destroy(); } |
### Question:
ActionsToolbox implements Toolbox<ActionsToolbox>,
Iterable<ToolboxAction> { @Override public void hideAndDestroy() { getView().hideAndDestroy(); actions.clear(); } ActionsToolbox(final Supplier<AbstractCanvasHandler> canvasHandlerSupplier,
final Element<?> element,
final V view); ActionsToolbox<V> init(); ActionsToolbox add(final ToolboxAction<AbstractCanvasHandler> action); @Override Iterator<ToolboxAction> iterator(); int size(); String getElementUUID(); AbstractCanvasHandler getCanvasHandler(); AbstractCanvas getCanvas(); Shape<?> getShape(); @Override ActionsToolbox show(); @Override ActionsToolbox hide(); @Override void destroy(); @Override void hideAndDestroy(); V getView(); Glyph getGlyph(final ToolboxAction<AbstractCanvasHandler> action); String getTitle(final ToolboxAction<AbstractCanvasHandler> action); }### Answer:
@Test public void testHideAndDestroy() { tested.hideAndDestroy(); verify(view, times(1)).hideAndDestroy(); } |
### Question:
CreateConnectorToolboxAction extends AbstractToolboxAction implements IsToolboxActionDraggable<AbstractCanvasHandler> { @Override protected String getTitleDefinitionId(final AbstractCanvasHandler canvasHandler, final String uuid) { return edgeId; } @Inject CreateConnectorToolboxAction(final DefinitionUtils definitionUtils,
final ClientFactoryManager clientFactoryManager,
final ClientTranslationService translationService,
final ConnectorProxy connectorProxy); CreateConnectorToolboxAction setEdgeId(final String edgeId); String getEdgeId(); @Override ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseClickEvent event); @Override ToolboxAction<AbstractCanvasHandler> onMoveStart(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseMoveEvent event); @PreDestroy void destroy(); @Override int hashCode(); @Override boolean equals(final Object o); }### Answer:
@Test public void testTitle() { assertEquals(EDGE_ID, tested.getTitleDefinitionId(canvasHandler, NODE_UUID)); tested.getTitle(canvasHandler, NODE_UUID); verify(translationService, times(1)).getValue(eq(CreateConnectorToolboxAction.KEY_TITLE)); } |
### Question:
CreateConnectorToolboxAction extends AbstractToolboxAction implements IsToolboxActionDraggable<AbstractCanvasHandler> { @Override protected String getGlyphId(final AbstractCanvasHandler canvasHandler, final String uuid) { return edgeId; } @Inject CreateConnectorToolboxAction(final DefinitionUtils definitionUtils,
final ClientFactoryManager clientFactoryManager,
final ClientTranslationService translationService,
final ConnectorProxy connectorProxy); CreateConnectorToolboxAction setEdgeId(final String edgeId); String getEdgeId(); @Override ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseClickEvent event); @Override ToolboxAction<AbstractCanvasHandler> onMoveStart(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseMoveEvent event); @PreDestroy void destroy(); @Override int hashCode(); @Override boolean equals(final Object o); }### Answer:
@Test public void testGlyph() { assertEquals(EDGE_ID, tested.getGlyphId(canvasHandler, NODE_UUID)); tested.getGlyph(canvasHandler, NODE_UUID); verify(shapeFactory).getGlyph(EDGE_ID, AbstractToolboxAction.ToolboxGlyphConsumer.class); } |
### Question:
CommonActionsToolboxFactory extends AbstractActionsToolboxFactory { @PreDestroy public void destroy() { deleteNodeActionsDestroyer.execute(); viewsDestroyer.execute(); } @Inject CommonActionsToolboxFactory(final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final CanvasCommandFactory<AbstractCanvasHandler> commandFactory,
final @Default ManagedInstance<DeleteNodeToolboxAction> deleteNodeActions,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxView> views); CommonActionsToolboxFactory(final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final CanvasCommandFactory<AbstractCanvasHandler> commandFactory,
final Supplier<DeleteNodeToolboxAction> deleteNodeActions,
final Command deleteNodeActionsDestroyer,
final Supplier<ActionsToolboxView> views,
final Command viewsDestroyer); @Override @SuppressWarnings("unchecked") Collection<ToolboxAction<AbstractCanvasHandler>> getActions(final AbstractCanvasHandler canvasHandler,
final Element<?> e); @PreDestroy void destroy(); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(deleteNodeActionDestroyer, times(1)).execute(); verify(viewDestroyer, times(1)).execute(); } |
### Question:
ToolboxDomainLookups { public CommonDomainLookups get(final String definitionSetId) { CommonDomainLookups lookup = domainLookups.get(definitionSetId); if (null == lookup) { lookup = domainLookupInstances.get(); lookup.setDomain(definitionSetId); domainLookups.put(definitionSetId, lookup); } return lookup; } protected ToolboxDomainLookups(); @Inject ToolboxDomainLookups(final ManagedInstance<CommonDomainLookups> domainLookupInstances); CommonDomainLookups get(final String definitionSetId); @PreDestroy void destroy(); }### Answer:
@Test public void testGetCached() { String dsId = "ds1"; CommonDomainLookups lookups = tested.get(dsId); CommonDomainLookups lookups1 = tested.get(dsId); assertEquals(domainLookups, lookups); verify(domainLookups, times(1)).setDomain(eq(dsId)); } |
### Question:
ToolboxDomainLookups { @PreDestroy public void destroy() { domainLookups.clear(); domainLookupInstances.destroyAll(); } protected ToolboxDomainLookups(); @Inject ToolboxDomainLookups(final ManagedInstance<CommonDomainLookups> domainLookupInstances); CommonDomainLookups get(final String definitionSetId); @PreDestroy void destroy(); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(domainLookupsManagedInstances, times(1)).destroyAll(); } |
### Question:
MorphNodeToolboxAction extends AbstractToolboxAction { @Override protected String getGlyphId(final AbstractCanvasHandler canvasHandler, final String uuid) { return targetDefinitionId; } @Inject MorphNodeToolboxAction(final DefinitionUtils definitionUtils,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final CanvasCommandFactory<AbstractCanvasHandler> commandFactory,
final ClientTranslationService translationService,
final Event<CanvasSelectionEvent> selectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEventEvent); MorphNodeToolboxAction setMorphDefinition(final MorphDefinition morphDefinition); MorphNodeToolboxAction setTargetDefinitionId(final String targetDefinitionId); @Override @SuppressWarnings("unchecked") ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseClickEvent event); @PreDestroy void destroy(); @Override int hashCode(); @Override boolean equals(final Object o); }### Answer:
@Test public void testGlyph() { assertEquals(MORPH_TARGET_ID, tested.getGlyphId(canvasHandler, E_UUID)); tested.getGlyph(canvasHandler, E_UUID); verify(shapeFactory).getGlyph(MORPH_TARGET_ID, AbstractToolboxAction.ToolboxGlyphConsumer.class); } |
### Question:
DeleteNodeToolboxAction implements ToolboxAction<AbstractCanvasHandler> { @Override public String getTitle(final AbstractCanvasHandler canvasHandler, final String uuid) { return translationService.getValue(CoreTranslationMessages.DELETE); } @Inject DeleteNodeToolboxAction(final ClientTranslationService translationService,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @Any ManagedInstance<DefaultCanvasCommandFactory> commandFactories,
final DefinitionUtils definitionUtils,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); DeleteNodeToolboxAction(final ClientTranslationService translationService,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final ManagedInstance<DefaultCanvasCommandFactory> commandFactories,
final DefinitionUtils definitionUtils,
final Predicate<DeleteNodeToolboxAction> confirmDelete,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); @Override Glyph getGlyph(final AbstractCanvasHandler canvasHandler,
final String uuid); @Override String getTitle(final AbstractCanvasHandler canvasHandler,
final String uuid); @Override @SuppressWarnings("unchecked") ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseClickEvent event); @PreDestroy void destroy(); }### Answer:
@Test public void testTitle() { tested.getTitle(canvasHandler, E_UUID); verify(translationService, times(1)).getValue(eq(CoreTranslationMessages.DELETE)); } |
### Question:
CreateNodeToolboxAction extends AbstractToolboxAction implements IsToolboxActionDraggable<AbstractCanvasHandler> { @Override protected String getTitleDefinitionId(final AbstractCanvasHandler canvasHandler, final String uuid) { return nodeId; } @Inject CreateNodeToolboxAction(final @Any ManagedInstance<GeneralCreateNodeAction> createNodeActions,
final DefinitionUtils definitionUtils,
final ClientTranslationService translationService,
final ClientFactoryManager clientFactoryManager,
final NodeProxy nodeProxy); String getNodeId(); CreateNodeToolboxAction setNodeId(final String nodeId); CreateNodeToolboxAction setEdgeId(final String edgeId); @Override @SuppressWarnings("unchecked") ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseClickEvent event); @Override @SuppressWarnings("unchecked") ToolboxAction<AbstractCanvasHandler> onMoveStart(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseMoveEvent event); @PreDestroy void destroy(); @Override int hashCode(); @Override boolean equals(final Object o); }### Answer:
@Test public void testTitle() { assertEquals(TARGET_NODE_ID, tested.getTitleDefinitionId(canvasHandler, NODE_UUID)); tested.getTitle(canvasHandler, NODE_UUID); verify(translationService, times(1)).getValue(eq(CreateNodeToolboxAction.KEY_TITLE)); } |
### Question:
CreateNodeToolboxAction extends AbstractToolboxAction implements IsToolboxActionDraggable<AbstractCanvasHandler> { @Override protected String getGlyphId(final AbstractCanvasHandler canvasHandler, final String uuid) { return nodeId; } @Inject CreateNodeToolboxAction(final @Any ManagedInstance<GeneralCreateNodeAction> createNodeActions,
final DefinitionUtils definitionUtils,
final ClientTranslationService translationService,
final ClientFactoryManager clientFactoryManager,
final NodeProxy nodeProxy); String getNodeId(); CreateNodeToolboxAction setNodeId(final String nodeId); CreateNodeToolboxAction setEdgeId(final String edgeId); @Override @SuppressWarnings("unchecked") ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseClickEvent event); @Override @SuppressWarnings("unchecked") ToolboxAction<AbstractCanvasHandler> onMoveStart(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseMoveEvent event); @PreDestroy void destroy(); @Override int hashCode(); @Override boolean equals(final Object o); }### Answer:
@Test public void testGlyph() { assertEquals(TARGET_NODE_ID, tested.getGlyphId(canvasHandler, NODE_UUID)); tested.getGlyph(canvasHandler, NODE_UUID); verify(shapeFactory).getGlyph(TARGET_NODE_ID, AbstractToolboxAction.ToolboxGlyphConsumer.class); } |
### Question:
CreateNodeToolboxAction extends AbstractToolboxAction implements IsToolboxActionDraggable<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler, final String uuid, final MouseClickEvent event) { final GeneralCreateNodeAction action = lookupAction(canvasHandler, uuid); action.executeAction(canvasHandler, uuid, nodeId, edgeId); return this; } @Inject CreateNodeToolboxAction(final @Any ManagedInstance<GeneralCreateNodeAction> createNodeActions,
final DefinitionUtils definitionUtils,
final ClientTranslationService translationService,
final ClientFactoryManager clientFactoryManager,
final NodeProxy nodeProxy); String getNodeId(); CreateNodeToolboxAction setNodeId(final String nodeId); CreateNodeToolboxAction setEdgeId(final String edgeId); @Override @SuppressWarnings("unchecked") ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseClickEvent event); @Override @SuppressWarnings("unchecked") ToolboxAction<AbstractCanvasHandler> onMoveStart(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseMoveEvent event); @PreDestroy void destroy(); @Override int hashCode(); @Override boolean equals(final Object o); }### Answer:
@Test public void testOnMouseClick() { when(canvasLayoutUtils.getNext(eq(canvasHandler), eq(element), eq(targetNode))) .thenReturn(new Point2D(100d, 500d)); final MouseClickEvent event = mock(MouseClickEvent.class); when(event.getX()).thenReturn(100d); when(event.getY()).thenReturn(500d); ToolboxAction<AbstractCanvasHandler> cascade = tested.onMouseClick(canvasHandler, NODE_UUID, event); assertEquals(tested, cascade); verify(action).executeAction(canvasHandler, NODE_UUID, TARGET_NODE_ID, EDGE_ID); } |
### Question:
PrintHelper { public void print(final HTMLElement element) { final Window globalWindow = getGlobalWindow(); final Window printWindow = globalWindow.open("", "_blank"); final HTMLDocument printDocument = getWindowDocument(printWindow); writeElementIntoDocument(element, printDocument); changeMediaAttributesToAll(printDocument); copyStylesFromWindow(printDocument, globalWindow); setupPrintCommandOnPageLoad(printDocument, printWindow); } void print(final HTMLElement element); }### Answer:
@Test public void testPrint() { final HTMLElement element = mock(HTMLElement.class); final HTMLDocument printDocument = mock(HTMLDocument.class); final Window globalWindow = mock(Window.class); final Window printWindow = mock(Window.class); doReturn(globalWindow).when(helper).getGlobalWindow(); doReturn(printDocument).when(helper).getWindowDocument(printWindow); doNothing().when(helper).writeElementIntoDocument(any(), any()); doNothing().when(helper).changeMediaAttributesToAll(any()); doNothing().when(helper).copyStylesFromWindow(any(), any()); doNothing().when(helper).setupPrintCommandOnPageLoad(any(), any()); when(globalWindow.open("", "_blank")).thenReturn(printWindow); helper.print(element); verify(helper).writeElementIntoDocument(element, printDocument); verify(helper).changeMediaAttributesToAll(printDocument); verify(helper).copyStylesFromWindow(printDocument, globalWindow); verify(helper).setupPrintCommandOnPageLoad(printDocument, printWindow); } |
### Question:
PrintHelper { void writeElementIntoDocument(final HTMLElement element, final HTMLDocument document) { document.open(); document.write(element.innerHTML); document.close(); document.body.classList.add(PREVIEW_SCREEN_CSS_CLASS); } void print(final HTMLElement element); }### Answer:
@Test public void testWriteElementIntoDocument() { final HTMLElement element = mock(HTMLElement.class); final HTMLDocument document = mock(HTMLDocument.class); final HTMLBodyElement body = mock(HTMLBodyElement.class); final String elementHTML = "<html />"; final DOMTokenList classList = mock(DOMTokenList.class); element.innerHTML = elementHTML; document.body = body; body.classList = classList; helper.writeElementIntoDocument(element, document); verify(document).open(); verify(document).write(elementHTML); verify(document).close(); verify(classList).add(PREVIEW_SCREEN_CSS_CLASS); } |
### Question:
PrintHelper { void copyStylesFromWindow(final HTMLDocument printDocument, final Window window) { final HTMLDocument topDocument = getWindowDocument(window.top); final NodeList<Element> parentStyles = topDocument.querySelectorAll("style"); final Element documentHead = asElement(printDocument.querySelector("head")); for (int i = 0; i < parentStyles.length; i++) { final Element copiedStyle = createElement("style"); copiedStyle.innerHTML = asElement(parentStyles.item(i)).innerHTML; documentHead.appendChild(copiedStyle); } } void print(final HTMLElement element); }### Answer:
@Test public void testCopyStylesFromWindow() { final HTMLDocument document = mock(HTMLDocument.class); final HTMLDocument topDocument = mock(HTMLDocument.class); final Window window = mock(Window.class); final Window topWindow = mock(Window.class); final Element element = mock(Element.class); final Element head = mock(Element.class); final NodeList<Element> parentStyles = spy(new NodeList<>()); parentStyles.length = 1; window.top = topWindow; element.innerHTML = ".page { background: red }"; doReturn(element).when(parentStyles).item(0); doReturn(topDocument).when(helper).getWindowDocument(topWindow); doReturn(element).when(helper).asElement(element); doReturn(head).when(helper).asElement(head); doReturn(mock(Element.class)).when(helper).createElement("style"); when(document.querySelector("head")).thenReturn(head); when(topDocument.querySelectorAll("style")).thenReturn(parentStyles); helper.copyStylesFromWindow(document, window); verify(head).appendChild(elementArgumentCaptor.capture()); final Element copiedStyle = elementArgumentCaptor.getValue(); assertEquals(".page { background: red }", copiedStyle.innerHTML); } |
### Question:
PrintHelper { void setupPrintCommandOnPageLoad(final HTMLDocument printDocument, final Window printWindow) { printDocument.body.onload = (e) -> { setTimeout(() -> { printWindow.focus(); printWindow.print(); printWindow.close(); }, 10); return true; }; } void print(final HTMLElement element); }### Answer:
@Test public void testSetupPrintCommandOnPageLoad() { final HTMLDocument document = mock(HTMLDocument.class); final Window window = mock(Window.class); document.body = mock(HTMLBodyElement.class); doNothing().when(helper).setTimeout(any(), anyInt()); helper.setupPrintCommandOnPageLoad(document, window); document.body.onload.onInvoke(mock(Event.class)); verify(helper).setTimeout(commandArgumentCaptor.capture(), eq(10)); commandArgumentCaptor.getValue().execute(); verify(window).focus(); verify(window).print(); verify(window).close(); } |
### Question:
ClientUtils { public static String getSelectedElementUUID(ClientSession clientSession) { Optional<Collection<String>> selectedItems = Optional.empty(); if (clientSession instanceof EditorSession) { selectedItems = Optional.ofNullable(((EditorSession) clientSession).getSelectionControl().getSelectedItems()); } else if (clientSession instanceof ViewerSession) { selectedItems = Optional.ofNullable(((ViewerSession) clientSession).getSelectionControl().getSelectedItems()); } return selectedItems.map(strings -> strings.stream().findFirst().orElse(null)).orElse(null); } static String getSelectedElementUUID(ClientSession clientSession); static Node getSelectedNode(Diagram diagram, ClientSession clientSession); }### Answer:
@Test public void testGetSelectedElementUUIDWhenSelected() { assertEquals(ITEM_UUID, ClientUtils.getSelectedElementUUID(viewerSession)); assertEquals(ITEM_UUID, ClientUtils.getSelectedElementUUID(editorSession)); }
@Test public void testGetSelectedElementUUIDWhenNotSelected() { selectedItems.clear(); assertNull(ClientUtils.getSelectedElementUUID(viewerSession)); assertNull(ClientUtils.getSelectedElementUUID(editorSession)); } |
### Question:
ClientUtils { public static Node getSelectedNode(Diagram diagram, ClientSession clientSession) { String uuid = getSelectedElementUUID(clientSession); return uuid != null ? diagram.getGraph().getNode(uuid) : null; } static String getSelectedElementUUID(ClientSession clientSession); static Node getSelectedNode(Diagram diagram, ClientSession clientSession); }### Answer:
@Test public void testGetSelectedNodeWhenSelected() { Node node = mock(Node.class); when(graph.getNode(ITEM_UUID)).thenReturn(node); assertEquals(node, ClientUtils.getSelectedNode(diagram, viewerSession)); assertEquals(node, ClientUtils.getSelectedNode(diagram, editorSession)); }
@Test public void testGetSelectedNodeWhenNotSelected() { selectedItems.clear(); assertNull(ClientUtils.getSelectedNode(diagram, viewerSession)); assertNull(ClientUtils.getSelectedNode(diagram, editorSession)); } |
### Question:
ShapeUtils { public static void enforceLocationConstraints(final ShapeView shape, final Bounds bounds) { if (shape instanceof HasDragBounds) { ((HasDragBounds) shape).setDragBounds(bounds); } } @SuppressWarnings("unchecked") static void applyConnections(final Edge<? extends ViewConnector<?>, Node> edge,
final AbstractCanvasHandler canvasHandler,
final MutationContext mutationContext); static ConnectorShape getConnectorShape(Edge edge, CanvasHandler canvasHandler); @SuppressWarnings("unchecked") static void updateEdgeConnections(final Edge<? extends ViewConnector<?>, Node> edge,
final AbstractCanvasHandler context); @SuppressWarnings("unchecked") static void updateEdgeConnection(final AbstractCanvasHandler context,
final Connection connection,
final Node<? extends View<?>, Edge> node); static void enforceLocationConstraints(final ShapeView shape,
final Bounds bounds); @SuppressWarnings("unchecked") static void moveViewConnectorsToTop(final AbstractCanvasHandler canvasHandler,
final Node<?, Edge> node); static double getRadiusForBoundingBox(final double width,
final double height); static void setSizeFromBoundingBox(final ShapeView view,
final double boundingBoxWidth,
final double boundingBoxHeight); static double dist(final double x0,
final double y0,
final double x1,
final double y1); }### Answer:
@Test public void testEnforceLocationConstraints() { ShapeViewExtStub shape = spy(new ShapeViewExtStub()); Bounds bounds = mock(Bounds.class); ShapeUtils.enforceLocationConstraints(shape, bounds); verify(shape, times(1)).setDragBounds(eq(bounds)); } |
### Question:
SvgDataUriGenerator { public static String encodeUtf8(final String dataUriDecoded) { return SVG_DATA_URI_UTF8 + UriUtils.encode(dataUriDecoded).replace("#", "%23"); } static String encodeUtf8(final String dataUriDecoded); static String encodeBase64(final String dataUriDecoded); @SuppressWarnings("unchecked") String generate(final SafeUri svgUri); String generate(final SafeUri svgUri,
final Collection<SafeUri> svgDefs,
final Collection<String> validUseRefIds); static final String SVG_CONTENT_TYPE; static final String SVG_DATA_URI_BASE64; static final String SVG_DATA_URI_UTF8; }### Answer:
@Test public void testEncodeUTF8() { assertEquals(SvgDataUriGenerator.SVG_DATA_URI_UTF8 + "%3C?xml", SvgDataUriGenerator.encodeUtf8("<?xml")); assertEquals(SvgDataUriGenerator.SVG_DATA_URI_UTF8 + "%3Csvg%20id=%22Layer_Main%22%20", SvgDataUriGenerator.encodeUtf8("<svg id=\"Layer_Main\" ")); assertEquals(SvgDataUriGenerator.SVG_DATA_URI_UTF8 + "%3Cuse%20xlink:href=%22%23Layer_3%22", SvgDataUriGenerator.encodeUtf8("<use xlink:href=\"#Layer_3\"")); } |
### Question:
SvgDataUriGenerator { public static String encodeBase64(final String dataUriDecoded) { return SVG_DATA_URI_BASE64 + Base64Util.encode(dataUriDecoded.getBytes(), 0, dataUriDecoded.length()); } static String encodeUtf8(final String dataUriDecoded); static String encodeBase64(final String dataUriDecoded); @SuppressWarnings("unchecked") String generate(final SafeUri svgUri); String generate(final SafeUri svgUri,
final Collection<SafeUri> svgDefs,
final Collection<String> validUseRefIds); static final String SVG_CONTENT_TYPE; static final String SVG_DATA_URI_BASE64; static final String SVG_DATA_URI_UTF8; }### Answer:
@Test public void testEncodeBase64() { assertEquals(SvgDataUriGenerator.SVG_DATA_URI_BASE64 + "PD94bWw=", SvgDataUriGenerator.encodeBase64("<?xml")); assertEquals(SvgDataUriGenerator.SVG_DATA_URI_BASE64 + "PHN2ZyBpZD0iTGF5ZXJfTWFpbiIg", SvgDataUriGenerator.encodeBase64("<svg id=\"Layer_Main\" ")); assertEquals(SvgDataUriGenerator.SVG_DATA_URI_BASE64 + "PHVzZSB4bGluazpocmVmPSIjTGF5ZXJfMyI=", SvgDataUriGenerator.encodeBase64("<use xlink:href=\"#Layer_3\"")); } |
### Question:
ShapeDefFunctionalFactory implements ShapeDefFactory<W, D, S> { @Override @SuppressWarnings("unchecked") public S newShape(final W instance, final D shapeDef) { return (S) newShape(instance, shapeDef, shapeDef.getType()); } @SuppressWarnings("unchecked") ShapeDefFunctionalFactory<W, D, S> set(final Class<? extends D> shapeDefType,
final BiFunction<W, D, S> shapeBuilderFunction); @Override @SuppressWarnings("unchecked") S newShape(final W instance,
final D shapeDef); @PreDestroy void destroy(); }### Answer:
@Test(expected = RuntimeException.class) @SuppressWarnings("unchecked") public void testNoDefinitionRegistered() { this.tested.newShape(definitionBean, shapeDef1); } |
### Question:
DelegateShapeFactory extends AbstractShapeFactory<W, S> { @Override @SuppressWarnings("unchecked") public S newShape(final W definition) { final DefinitionTypeBindings bindings = getBindings(definition.getClass()); final ShapeDef<? extends W> shapeDef = bindings.shapeDef; return (S) bindings.factory.get() .newShape(definition, shapeDef); } DelegateShapeFactory(); DelegateShapeFactory<W, S> delegate(final Class<? extends W> definitionType,
final ShapeDef<? extends W> shapeDef,
final Supplier<? extends ShapeDefFactory> factory); @Override @SuppressWarnings("unchecked") S newShape(final W definition); @PreDestroy void destroy(); }### Answer:
@Test(expected = RuntimeException.class) @SuppressWarnings("unchecked") public void testNoBindingFound() { tested.newShape(definition1); } |
### Question:
ImageStripRegistry { public ImageStrip get(final String name) { return StreamSupport.stream(stripInstances.spliterator(), false) .filter(strip -> getName(strip).equals(name)) .findAny() .get(); } protected ImageStripRegistry(); @Inject ImageStripRegistry(final @Any ManagedInstance<ImageStrip> stripInstances); ImageStrip get(final String name); ImageStrip get(final Class<? extends ImageStrip> stripType); ImageStrip[] get(final Annotation... qualifiers); @PreDestroy void destroy(); @SuppressWarnings("unchecked") static String getName(final ImageStrip strip); static String getName(final Class<? extends ImageStrip> stripType); }### Answer:
@Test public void testGetByType() { final ImageStrip result = tested.get(ImageStripTestInstance.class); assertEquals(strip, result); verify(stripInstances, times(1)).select(eq(ImageStripTestInstance.class)); }
@Test public void testGetByQualifier() { Annotation qualifier = mock(Annotation.class); final ImageStrip[] result = tested.get(qualifier); assertEquals(1, result.length); assertEquals(strip, result[0]); verify(stripInstances, times(1)).select(eq(qualifier)); } |
### Question:
ImageStripRegistry { @PreDestroy public void destroy() { stripInstances.destroyAll(); } protected ImageStripRegistry(); @Inject ImageStripRegistry(final @Any ManagedInstance<ImageStrip> stripInstances); ImageStrip get(final String name); ImageStrip get(final Class<? extends ImageStrip> stripType); ImageStrip[] get(final Annotation... qualifiers); @PreDestroy void destroy(); @SuppressWarnings("unchecked") static String getName(final ImageStrip strip); static String getName(final Class<? extends ImageStrip> stripType); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(stripInstances, times(1)).destroyAll(); } |
### Question:
ShapeStateAttributesFactory { public static ShapeStateAttributes buildStrokeAttributes(final ShapeState state) { final String COLOR = getAttributeColorByState(state); if (null == COLOR) { return buildAttributes(); } return buildAttributes() .set(ShapeStateAttribute.STROKE_ALPHA, 1d) .set(ShapeStateAttribute.STROKE_COLOR, COLOR); } static ShapeStateAttributes buildStrokeAttributes(final ShapeState state); static ShapeStateAttributes buildFillAttributes(final ShapeState state); }### Answer:
@Test public void testBuildStrokeAttributes() { ShapeStateAttributeHandler.ShapeStateAttributes attributes = strokeAttributes.apply(NONE); attributes.getValues().values().forEach( state -> assertEquals(null, state) ); assertStrokeAttributes(strokeAttributes.apply(SELECTED), COLOR_SELECTED); assertStrokeAttributes(strokeAttributes.apply(HIGHLIGHT), COLOR_HIGHLIGHT); assertStrokeAttributes(strokeAttributes.apply(INVALID), COLOR_INVALID); } |
### Question:
ShapeStateAttributesFactory { public static ShapeStateAttributes buildFillAttributes(final ShapeState state) { final String COLOR = getAttributeColorByState(state); if (null == COLOR) { return buildAttributes(); } return buildAttributes() .set(ShapeStateAttribute.FILL_COLOR, COLOR) .set(ShapeStateAttribute.FILL_ALPHA, 1d); } static ShapeStateAttributes buildStrokeAttributes(final ShapeState state); static ShapeStateAttributes buildFillAttributes(final ShapeState state); }### Answer:
@Test public void testBuildFillAttributes() { ShapeStateAttributeHandler.ShapeStateAttributes attributes = fillAttributes.apply(NONE); attributes.getValues().values().forEach( state -> assertEquals(null, state) ); assertFillAttributes(fillAttributes.apply(SELECTED), COLOR_SELECTED); assertFillAttributes(fillAttributes.apply(INVALID), COLOR_INVALID); assertFillAttributes(fillAttributes.apply(HIGHLIGHT), COLOR_HIGHLIGHT); } |
### Question:
ConnectorShape extends AbstractElementShape<W, ViewConnector<W>, Edge<ViewConnector<W>, Node>, D, V> implements EdgeShape<W, ViewConnector<W>, Edge<ViewConnector<W>, Node>, V>,
Lifecycle { @Override public void applyState(final ShapeState shapeState) { getShape().applyState(shapeState); } ConnectorShape(final D shapeDef,
final V view,
final ShapeStateHandler shapeStateHelper); @Override void applyConnections(final Edge<ViewConnector<W>, Node> element,
final ShapeView<?> source,
final ShapeView<?> target,
final MutationContext mutationContext); @Override void applyPosition(final Edge<ViewConnector<W>, Node> element,
final MutationContext mutationContext); @Override void applyState(final ShapeState shapeState); }### Answer:
@Test @SuppressWarnings("unchecked") public void testApplyState() { tested.applyState(ShapeState.NONE); verify(shapeStateHandler, never()).shapeAttributesChanged(); verify(shapeStateHandler, times(1)).applyState(eq(ShapeState.NONE)); } |
### Question:
ShapeImpl extends AbstractShape<V> { @Override public void applyState(final ShapeState shapeState) { shapeStateHandler .applyState(shapeState); } ShapeImpl(final V view,
final ShapeStateHandler shapeStateHandler); void setUUID(final String uuid); @Override String getUUID(); @Override void beforeDraw(); @Override void afterDraw(); @Override void applyState(final ShapeState shapeState); ShapeStateHandler getShapeStateHandler(); @Override V getShapeView(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testApplyState() { tested.applyState(ShapeState.NONE); verify(shapeStateHandler, never()).shapeAttributesChanged(); verify(shapeStateHandler, times(1)).applyState(eq(ShapeState.NONE)); } |
### Question:
ShapeImpl extends AbstractShape<V> { @Override public void afterDraw() { if (view instanceof HasTitle) { ((HasTitle) view).moveTitleToTop(); } } ShapeImpl(final V view,
final ShapeStateHandler shapeStateHandler); void setUUID(final String uuid); @Override String getUUID(); @Override void beforeDraw(); @Override void afterDraw(); @Override void applyState(final ShapeState shapeState); ShapeStateHandler getShapeStateHandler(); @Override V getShapeView(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void testAfterDraw() { tested.afterDraw(); verify(view, times(1)).moveTitleToTop(); } |
### Question:
ListSelectorHeaderItemViewImpl implements ListSelectorHeaderItemView { @Override public void setText(final String text) { this.text.setTextContent(text); } ListSelectorHeaderItemViewImpl(); @Inject ListSelectorHeaderItemViewImpl(final Span text, final Icon icon); @Override void setText(final String text); @Override void setIconClass(final String iconClass); }### Answer:
@Test public void testSetText() { final String text = "TEXT"; headerItemView.setText(text); verify(this.text).setTextContent(text); } |
### Question:
NodeShapeImpl extends AbstractElementShape<W, View<W>, Node<View<W>, Edge>, D, V> implements NodeShape<W, View<W>, Node<View<W>, Edge>, V>,
Lifecycle { @Override public void applyPosition(final Node<View<W>, Edge> element, final MutationContext mutationContext) { final Point2D location = GraphUtils.getPosition(element.getContent()); getShapeView().setShapeLocation(location); } NodeShapeImpl(final D shapeDef,
final AbstractShape<V> shape); @Override void applyPosition(final Node<View<W>, Edge> element,
final MutationContext mutationContext); @Override void applyState(final ShapeState shapeState); }### Answer:
@Test public void testApplyPosition() { tested.applyPosition(element, MutationContext.STATIC); verify(view, times(1)).setShapeLocation(new Point2D(10d, 20d)); } |
### Question:
NodeShapeImpl extends AbstractElementShape<W, View<W>, Node<View<W>, Edge>, D, V> implements NodeShape<W, View<W>, Node<View<W>, Edge>, V>,
Lifecycle { @Override public void applyState(final ShapeState shapeState) { getShape().applyState(shapeState); } NodeShapeImpl(final D shapeDef,
final AbstractShape<V> shape); @Override void applyPosition(final Node<View<W>, Edge> element,
final MutationContext mutationContext); @Override void applyState(final ShapeState shapeState); }### Answer:
@Test public void testApplyProperties() { when(shapeStateHandler.reset()).thenReturn(ShapeState.NONE); tested.applyProperties(element, MutationContext.STATIC); verify(shapeStateHandler, times(1)).reset(); verify(shapeStateHandler, times(1)).shapeAttributesChanged(); verify(shapeStateHandler, times(1)).applyState(eq(ShapeState.NONE)); verify(viewHandler, times(1)).accept(eq(definition), eq(view)); verify(sizeHandler, times(1)).accept(eq(content), eq(view)); }
@Test public void testApplyState() { tested.applyState(ShapeState.INVALID); verify(shapeStateHandler, times(1)).applyState(eq(ShapeState.INVALID)); } |
### Question:
ShapeStateAttributeHandler implements ShapeStateHandler { public ShapeStateAttributeHandler<V> setView(final Supplier<V> viewSupplier) { setViewSupplier(viewSupplier); this.state = ShapeState.NONE; saveState(); return this; } ShapeStateAttributeHandler(); ShapeStateAttributeHandler(final BiConsumer<V, ShapeStateAttributes> stateAttributesApplier); static BiConsumer<V, ShapeStateAttributes> newDefaultStateApplier(); ShapeStateAttributeHandler<V> useAttributes(final Function<ShapeState, ShapeStateAttributes> stateAttributesProvider); ShapeStateAttributeHandler<V> setView(final Supplier<V> viewSupplier); @Override ShapeStateAttributeHandler<V> shapeAttributesChanged(); @Override void applyState(final ShapeState shapeState); @Override ShapeState reset(); @Override ShapeState getShapeState(); V getShapeView(); }### Answer:
@Test public void testSetView() { assertEquals(tested, tested.setView(viewSupplier)); assertEquals(view, tested.getShapeView()); assertEquals(ShapeState.NONE, tested.getShapeState()); assertEquals(FILL, tested.getStateHolder().getValues().get(ShapeStateAttribute.FILL_COLOR)); assertEquals(FILL_ALPHA, tested.getStateHolder().getValues().get(ShapeStateAttribute.FILL_ALPHA)); assertEquals(STROKE, tested.getStateHolder().getValues().get(ShapeStateAttribute.STROKE_COLOR)); assertEquals(STROKE_ALPHA, tested.getStateHolder().getValues().get(ShapeStateAttribute.STROKE_ALPHA)); assertEquals(STROKE_WIDTH, tested.getStateHolder().getValues().get(ShapeStateAttribute.STROKE_WIDTH)); } |
### Question:
ShapeStateAttributeHandler implements ShapeStateHandler { @Override public ShapeState reset() { final ShapeState result = this.state; newDefaultStateApplier() .accept(getShapeView(), stateHolder.copy()); this.state = ShapeState.NONE; return result; } ShapeStateAttributeHandler(); ShapeStateAttributeHandler(final BiConsumer<V, ShapeStateAttributes> stateAttributesApplier); static BiConsumer<V, ShapeStateAttributes> newDefaultStateApplier(); ShapeStateAttributeHandler<V> useAttributes(final Function<ShapeState, ShapeStateAttributes> stateAttributesProvider); ShapeStateAttributeHandler<V> setView(final Supplier<V> viewSupplier); @Override ShapeStateAttributeHandler<V> shapeAttributesChanged(); @Override void applyState(final ShapeState shapeState); @Override ShapeState reset(); @Override ShapeState getShapeState(); V getShapeView(); }### Answer:
@Test public void testReset() { tested.setView(viewSupplier); tested.reset(); assertEquals(ShapeState.NONE, tested.getShapeState()); verify(view, times(1)).setFillColor(eq(FILL)); verify(view, times(1)).setFillAlpha(eq(FILL_ALPHA)); verify(view, times(1)).setStrokeColor(eq(STROKE)); verify(view, times(1)).setStrokeAlpha(eq(STROKE_ALPHA)); verify(view, times(1)).setStrokeWidth(eq(STROKE_WIDTH)); } |
### Question:
ClearSessionCommand extends AbstractClientSessionCommand<EditorSession> { @Override public boolean accepts(final ClientSession session) { return session instanceof EditorSession; } protected ClearSessionCommand(); @Inject ClearSessionCommand(final @Any ManagedInstance<CanvasCommandFactory<AbstractCanvasHandler>> canvasCommandFactoryInstance,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Event<ClearSessionCommandExecutedEvent> commandExecutedEvent,
final DefinitionUtils definitionUtils); @Override void bind(final EditorSession session); @Override boolean accepts(final ClientSession session); @Override @SuppressWarnings("unchecked") void execute(final Callback<V> callback); }### Answer:
@Test public void testAcceptsSession() { assertTrue(command.accepts(mock(EditorSession.class))); assertFalse(command.accepts(mock(ViewerSession.class))); } |
### Question:
AbstractSelectionAwareSessionCommand extends AbstractClientSessionCommand<S> { protected void onCanvasElementsClearEvent(final @Observes CanvasElementsClearEvent event) { checkNotNull("event", event); if (checkEventContext(event)) { handleCanvasElementsClearEvent(event); } } AbstractSelectionAwareSessionCommand(final boolean enabled); }### Answer:
@Test public void testOnCanvasElementsClearEvent() { CanvasElementsClearEvent event = new CanvasElementsClearEvent(canvasHandler); command.onCanvasElementsClearEvent(event); verify(command, times(1)).handleCanvasElementsClearEvent(event); event = new CanvasElementsClearEvent(anotherCanvasHandler); command.onCanvasElementsClearEvent(event); verify(command, never()).handleCanvasElementsClearEvent(event); } |
### Question:
AbstractSelectionAwareSessionCommand extends AbstractClientSessionCommand<S> { protected boolean onlyCanvasRootSelected(final CanvasSelectionEvent event) { return event.getIdentifiers().size() == 1 && getCanvasHandler().getDiagram().getMetadata().getCanvasRootUUID().equals(event.getIdentifiers().iterator().next()); } AbstractSelectionAwareSessionCommand(final boolean enabled); }### Answer:
@Test public void testOnlyCanvasRootSelected() { List<String> selectedNodes = new ArrayList<>(); assertFalse(command.onlyCanvasRootSelected(new CanvasSelectionEvent(canvasHandler, selectedNodes))); selectedNodes.clear(); selectedNodes.add("one"); selectedNodes.add("two"); assertFalse(command.onlyCanvasRootSelected(new CanvasSelectionEvent(canvasHandler, selectedNodes))); selectedNodes.clear(); selectedNodes.add("one"); selectedNodes.add(CANVAS_ROOT_ID); assertFalse(command.onlyCanvasRootSelected(new CanvasSelectionEvent(canvasHandler, selectedNodes))); selectedNodes.clear(); selectedNodes.add(CANVAS_ROOT_ID); assertTrue(command.onlyCanvasRootSelected(new CanvasSelectionEvent(canvasHandler, selectedNodes))); } |
### Question:
ListSelectorHeaderItemViewImpl implements ListSelectorHeaderItemView { @Override public void setIconClass(final String iconClass) { this.icon.getElement().setClassName(iconClass); } ListSelectorHeaderItemViewImpl(); @Inject ListSelectorHeaderItemViewImpl(final Span text, final Icon icon); @Override void setText(final String text); @Override void setIconClass(final String iconClass); }### Answer:
@Test public void testSetIconClass() { final String iconClass = "class"; final Element element = mock(Element.class); when(this.icon.getElement()).thenReturn(element); headerItemView.setIconClass(iconClass); verify(element).setClassName(iconClass); } |
### Question:
ExportToJpgSessionCommand extends AbstractExportSessionCommand { @Override protected void export(final String fileName) { canvasFileExport.exportToJpg(getSession().getCanvasHandler(), fileName); } protected ExportToJpgSessionCommand(); @Inject ExportToJpgSessionCommand(final CanvasFileExport canvasFileExport); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExport() { this.tested.execute(callback); verify(canvasFileExport, times(1)).exportToJpg(eq(canvasHandler), eq(FILE_NAME)); verify(canvasFileExport, never()).exportToPng(any(AbstractCanvasHandler.class), anyString()); verify(canvasFileExport, never()).exportToPdf(any(AbstractCanvasHandler.class), anyString()); } |
### Question:
SessionSingletonCommandsFactory { public static void createOrPut(AbstractSelectionAwareSessionCommand<EditorSession> command, SessionManager sessionManager) { if (sessionManager == null) { throw new IllegalStateException("Session Manager is Null"); } if (command instanceof CopySelectionSessionCommand) { if (copySessionInstances.containsKey(sessionManager.getCurrentSession())) { throw new IllegalStateException("Only one instance of CopySelectionSessionCommand per Client Session can exist"); } copySessionInstances.put(sessionManager.getCurrentSession(), (CopySelectionSessionCommand) command); } else if (command instanceof DeleteSelectionSessionCommand) { if (deleteSessionInstances.containsKey(sessionManager.getCurrentSession())) { throw new IllegalStateException("Only one instance of DeleteSelectionSessionCommand per Client Session can exist"); } deleteSessionInstances.put(sessionManager.getCurrentSession(), (DeleteSelectionSessionCommand) command); } else { throw new UnsupportedOperationException("Session Command Not Compatible Yet : " + command.getClass()); } } static void createOrPut(AbstractSelectionAwareSessionCommand<EditorSession> command, SessionManager sessionManager); static CopySelectionSessionCommand getInstanceCopy(
final Event<?> commandExecutedEvent,
SessionManager sessionManager); static DeleteSelectionSessionCommand getInstanceDelete(
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final ManagedInstance<CanvasCommandFactory<AbstractCanvasHandler>> canvasCommandFactoryInstance,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testOnlyAllowedCommands() { final CutSelectionSessionCommand cut = new CutSelectionSessionCommand(commandExecutedEvent, sessionManager); SessionSingletonCommandsFactory.createOrPut(cut, sessionManager); } |
### Question:
SessionSingletonCommandsFactory { public static DeleteSelectionSessionCommand getInstanceDelete( final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager, final ManagedInstance<CanvasCommandFactory<AbstractCanvasHandler>> canvasCommandFactoryInstance, final Event<CanvasClearSelectionEvent> clearSelectionEvent, final DefinitionUtils definitionUtils, final SessionManager sessionManager) { final ClientSession currentSession = sessionManager.getCurrentSession(); if (!deleteSessionInstances.containsKey(currentSession)) { return new DeleteSelectionSessionCommand(sessionCommandManager, canvasCommandFactoryInstance, clearSelectionEvent, definitionUtils, sessionManager); } return deleteSessionInstances.get(currentSession); } static void createOrPut(AbstractSelectionAwareSessionCommand<EditorSession> command, SessionManager sessionManager); static CopySelectionSessionCommand getInstanceCopy(
final Event<?> commandExecutedEvent,
SessionManager sessionManager); static DeleteSelectionSessionCommand getInstanceDelete(
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final ManagedInstance<CanvasCommandFactory<AbstractCanvasHandler>> canvasCommandFactoryInstance,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager); }### Answer:
@Test public void testGetInstancesDelete() { final DeleteSelectionSessionCommand deleteSelectionSessionCommand = new DeleteSelectionSessionCommand(null, null, null, null, sessionManager); final DeleteSelectionSessionCommand instanceCopy = SessionSingletonCommandsFactory.getInstanceDelete(null, null, null, null, sessionManager); assertEquals(deleteSelectionSessionCommand, instanceCopy); when(sessionManager.getCurrentSession()).thenReturn(session2); final DeleteSelectionSessionCommand deleteSelectionSessionCommand2 = new DeleteSelectionSessionCommand(null, null, null, null, sessionManager); final DeleteSelectionSessionCommand instanceCopy2 = SessionSingletonCommandsFactory.getInstanceDelete(null, null, null, null, sessionManager); assertEquals(deleteSelectionSessionCommand2, instanceCopy2); }
@Test(expected = IllegalStateException.class) public void testGetInstancesOnFetchDelete() { final DeleteSelectionSessionCommand instanceCopy = SessionSingletonCommandsFactory.getInstanceDelete(null, null, null, null, sessionManager); final DeleteSelectionSessionCommand instanceCopy2 = new DeleteSelectionSessionCommand(null, null, null, null, sessionManager); } |
### Question:
SaveDiagramSessionCommand extends AbstractClientSessionCommand<EditorSession> { @Override public boolean accepts(final ClientSession session) { return session instanceof EditorSession; } @Inject SaveDiagramSessionCommand(); @Override void execute(final Callback<V> callback); @Override boolean accepts(final ClientSession session); }### Answer:
@Test public void testAcceptsSession() { assertTrue(command.accepts(mock(EditorSession.class))); assertFalse(command.accepts(mock(ViewerSession.class))); } |
### Question:
ExportToPngSessionCommand extends AbstractExportSessionCommand { @Override protected void export(final String fileName) { canvasFileExport.exportToPng(getSession().getCanvasHandler(), fileName); } protected ExportToPngSessionCommand(); @Inject ExportToPngSessionCommand(final CanvasFileExport canvasFileExport); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExport() { this.tested.execute(callback); verify(canvasFileExport, times(1)).exportToPng(eq(canvasHandler), eq(FILE_NAME)); verify(canvasFileExport, never()).exportToJpg(any(AbstractCanvasHandler.class), anyString()); verify(canvasFileExport, never()).exportToPdf(any(AbstractCanvasHandler.class), anyString()); } |
### Question:
ListSelector extends AbstractPopoverImpl<ListSelectorView, HasListSelectorControl> implements ListSelectorView.Presenter { @Override public void bind(final HasListSelectorControl bound, final int uiRowIndex, final int uiColumnIndex) { super.bind(bound, uiRowIndex, uiColumnIndex); binding.ifPresent(b -> { final List<ListSelectorItem> items = b.getItems(uiRowIndex, uiColumnIndex); if (items.isEmpty()) { bind(null, uiRowIndex, uiColumnIndex); } else { view.setItems(b.getItems(uiRowIndex, uiColumnIndex)); } }); } ListSelector(); @Inject ListSelector(final ListSelectorView view); @Override void onItemSelected(final ListSelectorItem item); @Override void bind(final HasListSelectorControl bound,
final int uiRowIndex,
final int uiColumnIndex); }### Answer:
@Test public void testShow() { listSelector.bind(bound, 0, 0); listSelector.show(); verify(view).show(Optional.empty()); }
@Test public void testHide() { listSelector.bind(bound, 0, 0); listSelector.hide(); verify(view).hide(); }
@Test public void testBindWithItems() { listSelector.bind(bound, 0, 0); verify(view).setItems(itemsCaptor.capture()); assertThat(itemsCaptor.getValue()).containsOnly(listSelectorItem1, listSelectorItem2); listSelector.show(); verify(view).show(Optional.empty()); }
@Test @SuppressWarnings("unchecked") public void testBindWithNoItems() { when(bound.getItems(anyInt(), anyInt())).thenReturn(Collections.emptyList()); listSelector.bind(bound, 0, 0); verify(view, never()).setItems(anyList()); listSelector.show(); verify(view, never()).show(Optional.empty()); } |
### Question:
AbstractExportSessionCommand extends AbstractClientSessionCommand<AbstractSession<AbstractCanvas, AbstractCanvasHandler>> { @Override public boolean accepts(final ClientSession session) { return true; } AbstractExportSessionCommand(final boolean enabled); @Override boolean accepts(final ClientSession session); @Override void execute(final Callback<T> callback); }### Answer:
@Test public void testAcceptsSession() { assertTrue(getCommand().accepts(mock(EditorSession.class))); assertTrue(getCommand().accepts(mock(ViewerSession.class))); } |
### Question:
RedoSessionCommand extends AbstractClientSessionCommand<EditorSession> { void onCurrentRegistryChanged(final @Observes CurrentRegistryChangedEvent currentRegistryChangedEvent) { checkState(); } protected RedoSessionCommand(); @Inject RedoSessionCommand(final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final RedoCommandHandler<Command<AbstractCanvasHandler, CanvasViolation>> redoCommandHandler); @Override void bind(final EditorSession session); @Override boolean accepts(final ClientSession session); @Override @SuppressWarnings("unchecked") void execute(final Callback<V> callback); }### Answer:
@Test public void testOnCurrentRegistryChanged() { final CurrentRegistryChangedEvent event = mock(CurrentRegistryChangedEvent.class); ((RedoSessionCommand)command).onCurrentRegistryChanged(event); verify((RedoSessionCommand)command).checkState(); } |
### Question:
UndoSessionCommand extends AbstractClientSessionCommand<EditorSession> { void onCurrentRegistryChanged(final @Observes CurrentRegistryChangedEvent currentRegistryChangedEvent) { checkState(); } @Inject UndoSessionCommand(final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager); @Override void bind(final EditorSession session); @Override boolean accepts(final ClientSession session); @Override @SuppressWarnings("unchecked") void execute(final Callback<V> callback); }### Answer:
@Test public void testOnCurrentRegistryChanged() { final CurrentRegistryChangedEvent event = mock(CurrentRegistryChangedEvent.class); ((UndoSessionCommand)command).onCurrentRegistryChanged(event); verify((UndoSessionCommand)command).checkState(); } |
### Question:
PasteSelectionSessionCommand extends AbstractClientSessionCommand<EditorSession> { protected void onCopySelectionCommandExecuted(@Observes CopySelectionSessionCommandExecutedEvent event) { checkNotNull("event", event); if (Objects.equals(getSession(), event.getClientSession())) { setEnabled(true); fire(); } } protected PasteSelectionSessionCommand(); @Inject PasteSelectionSessionCommand(final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
@Any ManagedInstance<CanvasCommandFactory<AbstractCanvasHandler>> canvasCommandFactoryInstance,
final Event<CanvasSelectionEvent> selectionEvent,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager); void setTestEdgeFoundInCanvas(boolean testEdgeFoundInCanvas); void setTestEdgeFoundInClipboard(boolean testEdgeFoundInClipboard); @Override void bind(final EditorSession session); @Override boolean accepts(final ClientSession session); @Override void execute(final Callback<V> callback); boolean isEdgeFoundInClipboard(Edge edge); boolean isEdgeFoundInCanvas(final Edge edge); boolean wasNodesDeletedFromGraph(); void clear(); String getCanvasViolations(CommandResult<CanvasViolation> result); }### Answer:
@Test public void testOnCopySelectionCommandExecuted() { pasteSelectionSessionCommand.bind(session); pasteSelectionSessionCommand.listen(statusCallback); pasteSelectionSessionCommand.onCopySelectionCommandExecuted(new CopySelectionSessionCommandExecutedEvent(mock(CopySelectionSessionCommand.class), session)); verify(statusCallback, times(1)).execute(); assertTrue(command.isEnabled()); } |
### Question:
PasteSelectionSessionCommand extends AbstractClientSessionCommand<EditorSession> { protected void onCutSelectionCommandExecuted(@Observes CutSelectionSessionCommandExecutedEvent event) { checkNotNull("event", event); if (Objects.equals(getSession(), event.getClientSession())) { setEnabled(true); fire(); } } protected PasteSelectionSessionCommand(); @Inject PasteSelectionSessionCommand(final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
@Any ManagedInstance<CanvasCommandFactory<AbstractCanvasHandler>> canvasCommandFactoryInstance,
final Event<CanvasSelectionEvent> selectionEvent,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager); void setTestEdgeFoundInCanvas(boolean testEdgeFoundInCanvas); void setTestEdgeFoundInClipboard(boolean testEdgeFoundInClipboard); @Override void bind(final EditorSession session); @Override boolean accepts(final ClientSession session); @Override void execute(final Callback<V> callback); boolean isEdgeFoundInClipboard(Edge edge); boolean isEdgeFoundInCanvas(final Edge edge); boolean wasNodesDeletedFromGraph(); void clear(); String getCanvasViolations(CommandResult<CanvasViolation> result); }### Answer:
@Test public void testOnCutSelectionCommandExecuted() { pasteSelectionSessionCommand.bind(session); pasteSelectionSessionCommand.listen(statusCallback); pasteSelectionSessionCommand.onCutSelectionCommandExecuted(new CutSelectionSessionCommandExecutedEvent(mock(CutSelectionSessionCommand.class), session)); verify(statusCallback, times(1)).execute(); assertTrue(command.isEnabled()); } |
### Question:
ExportToPdfSessionCommand extends AbstractExportSessionCommand { @Override protected void export(final String fileName) { canvasFileExport.exportToPdf(getSession().getCanvasHandler(), fileName); } protected ExportToPdfSessionCommand(); @Inject ExportToPdfSessionCommand(final CanvasFileExport canvasFileExport); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExport() { this.tested.execute(callback); verify(canvasFileExport, times(1)).exportToPdf(eq(canvasHandler), eq(FILE_NAME)); verify(canvasFileExport, never()).exportToJpg(any(AbstractCanvasHandler.class), anyString()); verify(canvasFileExport, never()).exportToPng(any(AbstractCanvasHandler.class), anyString()); } |
### Question:
ExportToRawFormatSessionCommand extends AbstractExportSessionCommand { @SuppressWarnings("unchecked") @Override protected void export(final String fileName) { clientDiagramService.getRawContent(getSession().getCanvasHandler().getDiagram(), new ServiceCallback<String>() { @Override public void onSuccess(String rawContent) { textFileExport.export(TextContent.create(rawContent), fileName); } @Override public void onError(ClientRuntimeError error) { errorPopupPresenter.showMessage(error.getMessage()); } }); } protected ExportToRawFormatSessionCommand(); @Inject ExportToRawFormatSessionCommand(final ClientDiagramService clientDiagramService,
final ErrorPopupPresenter errorPopupPresenter,
final TextFileExport textFileExport); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExportSuccessful() { command.execute(callback); verify(clientDiagramService, times(1)).getRawContent(eq(diagram), callbackCaptor.capture()); callbackCaptor.getValue().onSuccess(FILE_RAW_CONTENT); verify(textFileExport, times(1)).export(textContentCaptor.capture(), eq(FILE_NAME)); assertEquals(FILE_RAW_CONTENT, textContentCaptor.getValue().getText()); }
@Test @SuppressWarnings("unchecked") public void testExportUnSuccessful() { command.execute(callback); verify(clientDiagramService, times(1)).getRawContent(eq(diagram), callbackCaptor.capture()); callbackCaptor.getValue().onError(new ClientRuntimeError(ERROR)); verify(textFileExport, never()).export(anyObject(), anyObject()); verify(errorPopupPresenter, times(1)).showMessage(ERROR); } |
### Question:
ExportToSvgSessionCommand extends AbstractExportSessionCommand { @Override protected void export(final String fileName) { canvasFileExport.exportToSvg(getSession().getCanvasHandler(), fileName); } protected ExportToSvgSessionCommand(); @Inject ExportToSvgSessionCommand(final CanvasFileExport canvasFileExport); }### Answer:
@Test public void testExport() { tested.execute(callback); verify(canvasFileExport, times(1)).exportToSvg(eq(canvasHandler), eq(FILE_NAME)); verify(canvasFileExport, never()).exportToJpg(any(AbstractCanvasHandler.class), anyString()); verify(canvasFileExport, never()).exportToPdf(any(AbstractCanvasHandler.class), anyString()); verify(canvasFileExport, never()).exportToPng(any(AbstractCanvasHandler.class), anyString()); } |
### Question:
PerformAutomaticLayoutCommand extends AbstractClientSessionCommand<EditorSession> { UndoableLayoutExecutor makeExecutor() { return new UndoableLayoutExecutor(getCanvasHandler(), sessionCommandManager); } @Inject PerformAutomaticLayoutCommand(final LayoutHelper layoutHelper,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Event<LockRequiredEvent> locker); @Override boolean accepts(final ClientSession session); @Override void execute(final Callback<V> callback); }### Answer:
@Test public void testMakeExecutor() { final UndoableLayoutExecutor executor = command.makeExecutor(); assertEquals(canvasHandler, executor.getCanvasHandler()); assertEquals(commandManager, executor.getCommandManager()); } |
### Question:
PerformAutomaticLayoutCommand extends AbstractClientSessionCommand<EditorSession> { @Override public <V> void execute(final Callback<V> callback) { final Diagram diagram = getDiagram(); final UndoableLayoutExecutor executor = makeExecutor(); layoutHelper.applyLayout(diagram, executor, true); executeLock(); callback.onSuccess(); } @Inject PerformAutomaticLayoutCommand(final LayoutHelper layoutHelper,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Event<LockRequiredEvent> locker); @Override boolean accepts(final ClientSession session); @Override void execute(final Callback<V> callback); }### Answer:
@Test public void testExecute() { doReturn(diagram).when(command).getDiagram(); doReturn(executor).when(command).makeExecutor(); command.execute(callback); verify(layoutHelper).applyLayout(diagram, executor, true); verify(callback).onSuccess(); verify(command).executeLock(); } |
### Question:
DefaultViewerSession extends ViewerSession { @Override public void init(final Metadata metadata, final Command callback) { init(s -> s.registerCanvasControl(MediatorsControl.class) .registerCanvasHandlerControl(SelectionControl.class, MultipleSelection.class), metadata, callback); } @Inject DefaultViewerSession(final ManagedSession session,
final CanvasCommandManager<AbstractCanvasHandler> canvasCommandManager); @PostConstruct void constructInstance(); @Override void init(final Metadata metadata,
final Command callback); void init(final Consumer<ManagedSession> sessionControls,
final Metadata metadata,
final Command callback); @Override void open(); @Override void destroy(); @Override String getSessionUUID(); @Override AbstractCanvas getCanvas(); @Override AbstractCanvasHandler getCanvasHandler(); @Override CanvasCommandManager<AbstractCanvasHandler> getCommandManager(); @Override MediatorsControl<AbstractCanvas> getMediatorsControl(); @Override SelectionControl<AbstractCanvasHandler, Element> getSelectionControl(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testInit() { Metadata metadata = mock(Metadata.class); Command command = mock(Command.class); tested.init(metadata, command); verify(managedSession, times(1)).registerCanvasControl(eq(MediatorsControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(SelectionControl.class), eq(MultipleSelection.class)); verify(managedSession, times(1)).init(eq(metadata), eq(command)); } |
### Question:
DefaultViewerSession extends ViewerSession { @Override public void open() { session.open(); } @Inject DefaultViewerSession(final ManagedSession session,
final CanvasCommandManager<AbstractCanvasHandler> canvasCommandManager); @PostConstruct void constructInstance(); @Override void init(final Metadata metadata,
final Command callback); void init(final Consumer<ManagedSession> sessionControls,
final Metadata metadata,
final Command callback); @Override void open(); @Override void destroy(); @Override String getSessionUUID(); @Override AbstractCanvas getCanvas(); @Override AbstractCanvasHandler getCanvasHandler(); @Override CanvasCommandManager<AbstractCanvasHandler> getCommandManager(); @Override MediatorsControl<AbstractCanvas> getMediatorsControl(); @Override SelectionControl<AbstractCanvasHandler, Element> getSelectionControl(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testOpen() { tested.open(); verify(managedSession, times(1)).open(); } |
### Question:
DefaultViewerSession extends ViewerSession { @Override public void destroy() { session.destroy(); } @Inject DefaultViewerSession(final ManagedSession session,
final CanvasCommandManager<AbstractCanvasHandler> canvasCommandManager); @PostConstruct void constructInstance(); @Override void init(final Metadata metadata,
final Command callback); void init(final Consumer<ManagedSession> sessionControls,
final Metadata metadata,
final Command callback); @Override void open(); @Override void destroy(); @Override String getSessionUUID(); @Override AbstractCanvas getCanvas(); @Override AbstractCanvasHandler getCanvasHandler(); @Override CanvasCommandManager<AbstractCanvasHandler> getCommandManager(); @Override MediatorsControl<AbstractCanvas> getMediatorsControl(); @Override SelectionControl<AbstractCanvasHandler, Element> getSelectionControl(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testDestroy() { tested.destroy(); verify(managedSession, times(1)).destroy(); } |
### Question:
SessionLoader { public void load(final Metadata metadata, final ParameterizedCommand<StunnerPreferences> completeCallback, final ParameterizedCommand<Throwable> errorCallback) { final String definitionSetId = metadata.getDefinitionSetId(); final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); preferencesRegistryLoader.load(metadata, prefs -> { loadInitializers(metadata, qualifier, () -> { completeCallback.execute(prefs); }); }, errorCallback); } @Inject SessionLoader(final DefinitionUtils definitionUtils,
final StunnerPreferencesRegistryLoader preferencesRegistryLoader,
final @Any ManagedInstance<SessionInitializer> beanInstances); void load(final Metadata metadata,
final ParameterizedCommand<StunnerPreferences> completeCallback,
final ParameterizedCommand<Throwable> errorCallback); void destroy(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testLoad() { ParameterizedCommand<StunnerPreferences> completeCallback = mock(ParameterizedCommand.class); ParameterizedCommand<Throwable> errorCallback = mock(ParameterizedCommand.class); sessionLoader.load(metadata, completeCallback, errorCallback); verify(initializerInstances, times(1)).select(eq(DefinitionManager.DEFAULT_QUALIFIER)); verify(initializerInstances, times(1)).select(eq(qualifier)); verify(initializer, times(1)).init(eq(metadata), any(Command.class)); } |
### Question:
SessionLoader { public void destroy() { initializers.forEach(SessionInitializer::destroy); initializers.clear(); initializerInstances.destroyAll(); } @Inject SessionLoader(final DefinitionUtils definitionUtils,
final StunnerPreferencesRegistryLoader preferencesRegistryLoader,
final @Any ManagedInstance<SessionInitializer> beanInstances); void load(final Metadata metadata,
final ParameterizedCommand<StunnerPreferences> completeCallback,
final ParameterizedCommand<Throwable> errorCallback); void destroy(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testDestroy() { ParameterizedCommand<StunnerPreferences> completeCallback = mock(ParameterizedCommand.class); ParameterizedCommand<Throwable> errorCallback = mock(ParameterizedCommand.class); sessionLoader.load(metadata, completeCallback, errorCallback); sessionLoader.destroy(); verify(initializer, atLeastOnce()).destroy(); verify(initializerInstances, times(1)).destroyAll(); assertTrue(sessionLoader.getInitializers().isEmpty()); } |
### Question:
DefaultCanvasElementListener implements CanvasElementListener { @Override public void update(final Element item) { onElementRegistration(item, false, true); } DefaultCanvasElementListener(final Iterable<CanvasControl<AbstractCanvasHandler>> canvasControls); @Override void update(final Element item); @Override void register(final Element item); @Override void deregister(final Element item); @Override void clear(); Iterable<CanvasControl<AbstractCanvasHandler>> getCanvasControls(); }### Answer:
@Test public void testUpdate() { Element element = mock(Element.class); defaultCanvasElementListener.update(element); updatableRegistrationControls.forEach(control -> verify(control).update(element)); } |
### Question:
DefaultEditorSession extends EditorSession { @Override public void open() { session.open(); } @Inject DefaultEditorSession(final ManagedSession session,
final CanvasCommandManager<AbstractCanvasHandler> canvasCommandManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> commandRegistry,
final Event<RegisterChangedEvent> registerChangedEvent); @PostConstruct void constructInstance(); @Override void init(final Metadata metadata,
final Command callback); void init(final Consumer<ManagedSession> sessionControls,
final Metadata metadata,
final Command callback); @Override void open(); @Override void destroy(); @Override String getSessionUUID(); @Override AbstractCanvas getCanvas(); @Override AbstractCanvasHandler getCanvasHandler(); @Override CanvasCommandManager<AbstractCanvasHandler> getCommandManager(); @Override Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> getCommandRegistry(); @Override MediatorsControl<AbstractCanvas> getMediatorsControl(); @Override KeyboardControl<AbstractCanvas, ClientSession> getKeyboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> getClipboardControl(); @Override SelectionControl<AbstractCanvasHandler, Element> getSelectionControl(); @Override ConnectionAcceptorControl<AbstractCanvasHandler> getConnectionAcceptorControl(); @Override ContainmentAcceptorControl<AbstractCanvasHandler> getContainmentAcceptorControl(); @Override DockingAcceptorControl<AbstractCanvasHandler> getDockingAcceptorControl(); }### Answer:
@Test public void testOpen() { tested.open(); verify(managedSession, times(1)).open(); } |
### Question:
DefaultEditorSession extends EditorSession { @Override public void destroy() { commandRegistry.clear(); session.destroy(); } @Inject DefaultEditorSession(final ManagedSession session,
final CanvasCommandManager<AbstractCanvasHandler> canvasCommandManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> commandRegistry,
final Event<RegisterChangedEvent> registerChangedEvent); @PostConstruct void constructInstance(); @Override void init(final Metadata metadata,
final Command callback); void init(final Consumer<ManagedSession> sessionControls,
final Metadata metadata,
final Command callback); @Override void open(); @Override void destroy(); @Override String getSessionUUID(); @Override AbstractCanvas getCanvas(); @Override AbstractCanvasHandler getCanvasHandler(); @Override CanvasCommandManager<AbstractCanvasHandler> getCommandManager(); @Override Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> getCommandRegistry(); @Override MediatorsControl<AbstractCanvas> getMediatorsControl(); @Override KeyboardControl<AbstractCanvas, ClientSession> getKeyboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> getClipboardControl(); @Override SelectionControl<AbstractCanvasHandler, Element> getSelectionControl(); @Override ConnectionAcceptorControl<AbstractCanvasHandler> getConnectionAcceptorControl(); @Override ContainmentAcceptorControl<AbstractCanvasHandler> getContainmentAcceptorControl(); @Override DockingAcceptorControl<AbstractCanvasHandler> getDockingAcceptorControl(); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(commandRegistry, times(1)).clear(); verify(managedSession, times(1)).destroy(); } |
### Question:
InstanceUtils { public static <T> void destroy(final ManagedInstance<T> controlInstance, final T control, final Consumer<T> destroyer) { destroyer.accept(control); controlInstance.destroy(control); } @SuppressWarnings("unchecked") static T lookup(final ManagedInstance instance,
final Class<T> type,
final Annotation... qualifier); static T lookup(final ManagedInstance<T> instance,
final Annotation qualifier); static void destroyAll(final List<ManagedInstance<T>> controlInstances,
final List<T> controls,
final Consumer<T> destroyer); static void destroy(final ManagedInstance<T> controlInstance,
final T control,
final Consumer<T> destroyer); }### Answer:
@Test public void testDestroy() { final ManagedInstance managedInstance = mock(ManagedInstance.class); final Object control = mock(Object.class); final Consumer<Object> consumer = mock(Consumer.class); InstanceUtils.destroy(managedInstance, control, consumer); verify(consumer, times(1)).accept(eq(control)); verify(managedInstance, times(1)).destroy(eq(control)); } |
### Question:
SessionEventObserver { void onSessionDiagramOpenedEvent(@Observes final SessionDiagramOpenedEvent event) { final Diagram currentDiagram = event.getSession().getCanvasHandler().getDiagram(); sessionDiagramOpenedHandlers.stream() .filter(handler -> handler.accepts(currentDiagram)) .forEach(handler -> handler.onSessionDiagramOpened(event.getSession())); } SessionEventObserver(); @Inject SessionEventObserver(@Any final Instance<SessionDiagramOpenedHandler> sessionDiagramOpenedHandlersInstance,
@Any final Instance<SessionDiagramSavedHandler> sessionDiagramSavedHandlersInstance); }### Answer:
@Test public void testOnSessionDiagramOpenedEvent() { observer.onSessionDiagramOpenedEvent(new SessionDiagramOpenedEvent(session)); allSessionDiagramOpenedHandlers.forEach(handler -> verify(handler).accepts(diagram)); acceptsDiagramSessionDiagramOpenedHandlers.forEach(handler -> verify(handler).onSessionDiagramOpened(session)); dontAcceptsDiagramSessionDiagramOpenedHandlers.forEach(handler -> verify(handler, never()).onSessionDiagramOpened(session)); } |
### Question:
SessionEventObserver { void onSessionDiagramSavedEvent(@Observes final SessionDiagramSavedEvent event) { final Diagram currentDiagram = event.getSession().getCanvasHandler().getDiagram(); sessionDiagramSavedHandlers.stream() .filter(handler -> handler.accepts(currentDiagram)) .forEach(handler -> handler.onSessionDiagramSaved(event.getSession())); } SessionEventObserver(); @Inject SessionEventObserver(@Any final Instance<SessionDiagramOpenedHandler> sessionDiagramOpenedHandlersInstance,
@Any final Instance<SessionDiagramSavedHandler> sessionDiagramSavedHandlersInstance); }### Answer:
@Test public void testOnSessionDiagramSavedEvent() { observer.onSessionDiagramSavedEvent(new SessionDiagramSavedEvent(session)); allSessionDiagramSavedHandlers.forEach(handler -> verify(handler).accepts(diagram)); acceptsDiagramSessionDiagramSavedHandlers.forEach(handler -> verify(handler).onSessionDiagramSaved(session)); dontAcceptsDiagramSessionDiagramSavedHandlers.forEach(handler -> verify(handler, never()).onSessionDiagramSaved(session)); } |
### Question:
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void create(final Path path, final String name, final String defSetId, final ServiceCallback<Path> callback) { diagramServiceCaller.call(p -> callback.onSuccess(path), (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).create(path, name, defSetId); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }### Answer:
@Test @SuppressWarnings("unchecked") public void testCreate() { final String name = "d1"; final String defSetId = "id1"; final ServiceCallback<Path> callback = mock(ServiceCallback.class); tested.create(path, name, defSetId, callback); verify(diagramService, times(1)).create(eq(path), eq(name), eq(defSetId)); verify(callback, times(1)).onSuccess(any(Path.class)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); } |
### Question:
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void add(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(v -> { updateClientMetadata(diagram); callback.onSuccess(diagram); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }### Answer:
@Test @SuppressWarnings("unchecked") public void testAdd() { final ServiceCallback<D> callback = mock(ServiceCallback.class); tested.add(diagram, callback); verify(diagramService, times(1)).saveOrUpdate(eq(diagram)); verify(callback, times(1)).onSuccess(eq(diagram)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); } |
### Question:
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback) { diagramServiceCaller.call(res -> callback.onSuccess((Path) res)).saveOrUpdateSvg(diagramPath, rawSvg); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }### Answer:
@Test public void testSaveOrUpdateSvg() { final ServiceCallback<Path> callback = mock(ServiceCallback.class); tested.saveOrUpdateSvg(path, RAW_DIAGRAM, callback); verify(diagramService).saveOrUpdateSvg(path, RAW_DIAGRAM); } |
### Question:
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void getByPath(final Path path, final ServiceCallback<D> callback) { diagramServiceCaller.call(diagram -> { updateClientMetadata((D) diagram); callback.onSuccess((D) diagram); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).getDiagramByPath(path); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }### Answer:
@Test @SuppressWarnings("unchecked") public void testGetByPath() { final ServiceCallback<D> callback = mock(ServiceCallback.class); tested.getByPath(path, callback); verify(diagramService, times(1)).getDiagramByPath(eq(path)); verify(callback, times(1)).onSuccess(eq(diagram)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); } |
### Question:
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void getRawContent(final D diagram, final ServiceCallback<String> callback) { diagramServiceCaller.call(rawContent -> { callback.onSuccess((String) rawContent); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; } ).getRawContent(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }### Answer:
@Test @SuppressWarnings("unchecked") public void testGetRawContent() { final ServiceCallback<String> callback = mock(ServiceCallback.class); tested.getRawContent(diagram, callback); verify(diagramService, times(1)).getRawContent(eq(diagram)); verify(callback, times(1)).onSuccess(any(String.class)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); } |
### Question:
ClientRuleManager implements RuleManager { @PostConstruct public void init() { ruleEvaluationHandlerInstances.forEach(registry()::register); } protected ClientRuleManager(); @Inject ClientRuleManager(final CachedRuleManager ruleManager,
final @Any ManagedInstance<RuleEvaluationHandler> ruleEvaluationHandlerInstances); @PostConstruct void init(); @Override RuleHandlerRegistry registry(); @Override RuleViolations evaluate(final RuleSet ruleSet,
final RuleEvaluationContext context); }### Answer:
@Test public void testRegisterHandlers() { tested.init(); verify(registry, times(1)).register(eq(handler)); } |
### Question:
ClientRuleManager implements RuleManager { @Override public RuleHandlerRegistry registry() { return ruleManager.registry(); } protected ClientRuleManager(); @Inject ClientRuleManager(final CachedRuleManager ruleManager,
final @Any ManagedInstance<RuleEvaluationHandler> ruleEvaluationHandlerInstances); @PostConstruct void init(); @Override RuleHandlerRegistry registry(); @Override RuleViolations evaluate(final RuleSet ruleSet,
final RuleEvaluationContext context); }### Answer:
@Test public void testGetRegistry() { assertEquals(registry, tested.registry()); } |
### Question:
ListSelector extends AbstractPopoverImpl<ListSelectorView, HasListSelectorControl> implements ListSelectorView.Presenter { @Override public void onItemSelected(final ListSelectorItem item) { binding.ifPresent(b -> b.onItemSelected(item)); } ListSelector(); @Inject ListSelector(final ListSelectorView view); @Override void onItemSelected(final ListSelectorItem item); @Override void bind(final HasListSelectorControl bound,
final int uiRowIndex,
final int uiColumnIndex); }### Answer:
@Test public void testOnItemSelected() { listSelector.bind(bound, 0, 0); listSelector.onItemSelected(listSelectorItem2); verify(bound).onItemSelected(eq(listSelectorItem2)); } |
### Question:
ClientRuleManager implements RuleManager { @Override public RuleViolations evaluate(final RuleSet ruleSet, final RuleEvaluationContext context) { return ruleManager.evaluate(ruleSet, context); } protected ClientRuleManager(); @Inject ClientRuleManager(final CachedRuleManager ruleManager,
final @Any ManagedInstance<RuleEvaluationHandler> ruleEvaluationHandlerInstances); @PostConstruct void init(); @Override RuleHandlerRegistry registry(); @Override RuleViolations evaluate(final RuleSet ruleSet,
final RuleEvaluationContext context); }### Answer:
@Test public void testEvaluate() { RuleSet ruleSet = mock(RuleSet.class); RuleEvaluationContext context = mock(RuleEvaluationContext.class); tested.evaluate(ruleSet, context); verify(ruleManager, times(1)).evaluate(eq(ruleSet), eq(context)); } |
### Question:
ClientProfileManager extends AbstractProfileManager { @Override protected Function<String, Annotation> getQualifier() { return definitionUtils::getQualifier; } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }### Answer:
@Test public void testGetQualifier() { tested.getQualifier().apply("q1"); verify(definitionUtils, times(1)).getQualifier(eq("q1")); tested.getQualifier().apply("q2"); verify(definitionUtils, times(1)).getQualifier(eq("q2")); } |
### Question:
ClientProfileManager extends AbstractProfileManager { @Override protected Iterable<Profile> getAllProfileInstances() { return profileInstances; } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }### Answer:
@Test public void testGetAllProfileInstances() { Iterable<Profile> profiles = tested.getAllProfileInstances(); Iterator<Profile> iterator = profiles.iterator(); assertEquals(profile1, iterator.next()); assertEquals(profile2, iterator.next()); assertFalse(iterator.hasNext()); } |
### Question:
ClientProfileManager extends AbstractProfileManager { @Override protected Iterable<Profile> selectProfileInstances(final Annotation... qualifiers) { return profileInstances.select(qualifiers); } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }### Answer:
@Test public void testSelectProfileInstances() { Annotation qualifier = mock(Annotation.class); tested.selectProfileInstances(qualifier); verify(profileInstances, times(1)).select(eq(qualifier)); } |
### Question:
ClientProfileManager extends AbstractProfileManager { @PreDestroy public void destroy() { profileInstances.destroyAll(); } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(profileInstances, times(1)).destroyAll(); } |
### Question:
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void start() { getTarget().start(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }### Answer:
@Test public void testStart() { tested.start(); verify(lifecycle, times(1)).start(); verify(lifecycle, never()).complete(); verify(lifecycle, never()).rollback(); } |
### Question:
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void rollback() { getTarget().rollback(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }### Answer:
@Test public void testRollback() { tested.rollback(); verify(lifecycle, times(1)).rollback(); verify(lifecycle, never()).complete(); verify(lifecycle, never()).start(); } |
### Question:
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void complete() { getTarget().complete(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }### Answer:
@Test public void testComplete() { tested.complete(); verify(lifecycle, times(1)).complete(); verify(lifecycle, never()).rollback(); verify(lifecycle, never()).start(); } |
### Question:
MouseRequestLifecycle implements CommandRequestLifecycle { void onMouseDown(final @Observes CanvasMouseDownEvent event) { start(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }### Answer:
@Test public void testOnMouseDown() { tested.onMouseDown(mock(CanvasMouseDownEvent.class)); verify(lifecycle, times(1)).start(); verify(lifecycle, never()).complete(); verify(lifecycle, never()).rollback(); } |
### Question:
MouseRequestLifecycle implements CommandRequestLifecycle { void onMouseUp(final @Observes CanvasMouseUpEvent event) { complete(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }### Answer:
@Test public void testOnMouseUp() { tested.onMouseUp(mock(CanvasMouseUpEvent.class)); verify(lifecycle, times(1)).complete(); verify(lifecycle, never()).rollback(); verify(lifecycle, never()).start(); } |
### Question:
RequestCommands implements CommandRequestLifecycle { @Override public void rollback() { rollback = true; } RequestCommands(final Consumer<Command<AbstractCanvasHandler, CanvasViolation>> completedCommand,
final Consumer<Command<AbstractCanvasHandler, CanvasViolation>> rollbackCommand); @Override void start(); void push(Command<AbstractCanvasHandler, CanvasViolation> command); @Override void rollback(); @Override void complete(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testRollback() { Consumer<Command<AbstractCanvasHandler, CanvasViolation>> fireComplete = mock(Consumer.class); tested = new RequestCommands.Builder() .onComplete(fireComplete) .onRollback(c -> command = (CompositeCommand<AbstractCanvasHandler, CanvasViolation>) c) .build(); tested.start(); tested.push(c1); tested.push(c2); tested.rollback(); tested.push(c3); tested.complete(); assertNotNull(command); assertTrue(command.getCommands().contains(c1)); assertTrue(command.getCommands().contains(c2)); assertTrue(command.getCommands().contains(c3)); verify(fireComplete, never()).accept(any()); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @PostConstruct public void init() { lifecycle.listen(() -> this); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test public void testInit() { tested.init(); assertEquals(tested, lifecycle.getTarget()); verify(lifecycle, never()).start(); verify(lifecycle, never()).rollback(); verify(lifecycle, never()).complete(); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void start() { getDelegate().start(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test public void testStart() { tested.start(); verify(commandManager, times(1)).init(eq(session)); verify(commandManager, times(1)).start(); verify(commandManager, never()).rollback(); verify(commandManager, never()).complete(); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void complete() { getDelegate().complete(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test public void testComplete() { tested.start(); tested.complete(); verify(commandManager, times(1)).start(); verify(commandManager, times(1)).complete(); verify(commandManager, never()).rollback(); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void rollback() { getDelegate().rollback(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test public void testRollback() { tested.start(); tested.rollback(); verify(commandManager, times(1)).start(); verify(commandManager, times(1)).rollback(); verify(commandManager, never()).complete(); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command) { return runExceptionSafeOperation(() -> getDelegate().allow(command)); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testAllow() { Command<AbstractCanvasHandler, CanvasViolation> command = mock(Command.class); tested.allow(command); verify(commandManager, times(1)).allow(eq(command)); verify(commandManager, never()).execute(any()); verify(commandManager, never()).undo(); verify(commandManager, never()).undo(any(), any()); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command) { return runSafeOperation(() -> getDelegate().execute(command)); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { Command<AbstractCanvasHandler, CanvasViolation> command = mock(Command.class); tested.execute(command); verify(commandManager, times(1)).execute(eq(command)); verify(commandManager, never()).allow(any()); verify(commandManager, never()).undo(); verify(commandManager, never()).undo(any(), any()); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> undo() { return runSafeOperation(() -> getDelegate().undo()); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test public void testUndo() { tested.undo(); verify(commandManager, times(1)).undo(); verify(commandManager, never()).execute(any()); verify(commandManager, never()).allow(any()); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { void onSessionDestroyed(@Observes SessionDestroyedEvent event) { final String sessionUUID = event.getSessionUUID(); final RegistryAwareCommandManager commandManager = getCommandManagers().get(sessionUUID); commandManagerInstances.destroy(commandManager); getCommandManagers().remove(sessionUUID); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test public void testOnSessionDestroyed() { tested.start(); tested.onSessionDestroyed(new SessionDestroyedEvent(SESSION_ID, "diagram1", "graph1", mock(Metadata.class))); assertTrue(tested.getCommandManagers().isEmpty()); verify(commandManagerInstances, times(1)).destroy(eq(commandManager)); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @PreDestroy public void destroy() { getCommandManagers().clear(); commandManagerInstances.destroyAll(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test public void testDestroy() { tested.start(); tested.destroy(); assertTrue(tested.getCommandManagers().isEmpty()); verify(commandManagerInstances, times(1)).destroyAll(); } |
### Question:
RedoCommandHandler { @SuppressWarnings("unchecked") public CommandResult<?> execute(final Object context, final CommandManager commandManager) { if (registry.isEmpty()) { return GraphCommandResultBuilder.SUCCESS; } final C last = registry.peek(); return commandManager.execute(context, last); } protected RedoCommandHandler(); @Inject RedoCommandHandler(final DefaultRegistry<C> registry, final Event<RegisterChangedEvent> registerChangedEvent); boolean onUndoCommandExecuted(final C command); boolean onCommandExecuted(final C command); @SuppressWarnings("unchecked") CommandResult<?> execute(final Object context,
final CommandManager commandManager); void setSession(final ClientSession clientSession); boolean isEnabled(); void clear(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { Object obj = mock(Object.class); CommandManager manager = mock(CommandManager.class); CommandResult expectedResult = mock(CommandResult.class); when(commandRegistry.isEmpty()).thenReturn(false); when(commandRegistry.peek()).thenReturn(command1); when(manager.execute(anyObject(), eq(command1))).thenReturn(expectedResult); CommandResult actualResult = tested.execute(obj, manager); assertEquals(expectedResult, actualResult); verify(manager).execute(eq(obj), eq(command1)); }
@Test @SuppressWarnings("unchecked") public void testExecuteOnNull() { Object obj = mock(Object.class); CommandManager manager = mock(CommandManager.class); when(commandRegistry.isEmpty()).thenReturn(true); RedoCommandHandler tested = new RedoCommandHandler(commandRegistry, registerChangedEvent); assertEquals(GraphCommandResultBuilder.SUCCESS, tested.execute(obj, manager)); verify(manager, never()).execute(anyObject(), any(Command.class)); } |
### Question:
RedoCommandHandler { public void setSession(final ClientSession clientSession) { this.registry.setRegistryChangeListener(() -> registerChangedEvent.fire(new RegisterChangedEvent(clientSession.getCanvasHandler()))); } protected RedoCommandHandler(); @Inject RedoCommandHandler(final DefaultRegistry<C> registry, final Event<RegisterChangedEvent> registerChangedEvent); boolean onUndoCommandExecuted(final C command); boolean onCommandExecuted(final C command); @SuppressWarnings("unchecked") CommandResult<?> execute(final Object context,
final CommandManager commandManager); void setSession(final ClientSession clientSession); boolean isEnabled(); void clear(); }### Answer:
@Test public void testSetSession() { ClientSession session = mock(ClientSession.class); tested.setSession(session); verify(commandRegistry, times(1)).setRegistryChangeListener(any()); } |
### Question:
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command) { return allow(getCanvasHandler(), command); } RegistryAwareCommandManager(); @SuppressWarnings("unchecked") RegistryAwareCommandManager init(final ClientSession session); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }### Answer:
@Test public void testAllow() { tested.allow(COMMAND_SUCCESS1); verify(commandManager, times(1)).allow(eq(canvasHandler), eq(COMMAND_SUCCESS1)); verify(commandManager, never()).execute(any(), any()); verify(commandManager, never()).undo(any(), any()); verify(commandRegistry, never()).register(any()); verify(commandRegistry, never()).pop(); verify(commandRegistry, never()).peek(); verify(commandRegistry, never()).clear(); } |
### Question:
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command) { return execute(getCanvasHandler(), command); } RegistryAwareCommandManager(); @SuppressWarnings("unchecked") RegistryAwareCommandManager init(final ClientSession session); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }### Answer:
@Test public void testExecute() { tested.execute(COMMAND_SUCCESS1); verify(commandManager, times(1)).execute(eq(canvasHandler), eq(COMMAND_SUCCESS1)); verify(commandManager, never()).allow(any(), any()); verify(commandManager, never()).undo(any(), any()); verify(commandRegistry, times(1)).register(any()); assertEquals(1, commandRegistry.getHistory().size()); assertEquals(COMMAND_SUCCESS1, commandRegistry.getHistory().get(0)); verify(commandRegistry, never()).pop(); verify(commandRegistry, never()).peek(); verify(commandRegistry, never()).clear(); } |
### Question:
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { final Command<AbstractCanvasHandler, CanvasViolation> lastEntry = getCommandRegistry() .map(Registry::pop) .orElse(null); if (null != lastEntry) { return undo(context, lastEntry); } return CanvasCommandResultBuilder.failed(); } RegistryAwareCommandManager(); @SuppressWarnings("unchecked") RegistryAwareCommandManager init(final ClientSession session); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }### Answer:
@Test public void testUndo() { commandRegistry.register(COMMAND_SUCCESS1); tested.undo(); verify(commandManager, times(1)).undo(eq(canvasHandler), eq(COMMAND_SUCCESS1)); verify(commandManager, never()).execute(any(), any()); verify(commandManager, never()).allow(any(), any()); verify(commandRegistry, times(1)).pop(); } |
### Question:
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { @Override public RuleViolations evaluate(final GraphEvaluationContext context) { ((AbstractGraphEvaluationContext) context).setState(this::getState); return StatefulGraphEvaluationContexts.evaluate(context, c -> ruleManager.evaluate(ruleSet, c)); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testEvaluate() { StatefulGraphEvaluationState.StatefulContainmentState containmentState = new StatefulGraphEvaluationState.StatefulContainmentState(); when(state.getContainmentState()).thenReturn(containmentState); Element parent = new NodeImpl<>("parent"); Node child = new NodeImpl<>("child"); final NodeContainmentContext[] containmentContext = new NodeContainmentContext[1]; tested.evaluate(builder -> containmentContext[0] = builder.containment(parent, child)); verify(ruleManager, times(1)).evaluate(eq(ruleSet), eq(containmentContext[0])); assertEquals(parent, containmentState.getParent(child)); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.