method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
ActionsToolbox implements Toolbox<ActionsToolbox>,
Iterable<ToolboxAction> { public ActionsToolbox<V> init() { getView().init(this); return this; } 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 @SuppressWarnings("unchecked") public void testInit() { tested.init(); verify(view, times(1)).init(eq(tested)); } |
### Question:
ActionsToolbox implements Toolbox<ActionsToolbox>,
Iterable<ToolboxAction> { @Override public ActionsToolbox show() { if (lastToolBoxRendered.equals(this.uuid)) { return this; } lastToolBoxRendered = this.uuid; getView().show(); return this; } 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 testShow() { tested.show(); verify(view, times(1)).show(); }
@Test public void testShowOnlyOnce() { tested.show(); tested.show(); verify(view, times(1)).show(); } |
### Question:
ActionsToolbox implements Toolbox<ActionsToolbox>,
Iterable<ToolboxAction> { @Override public ActionsToolbox hide() { getView().hide(); return this; } 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 testHide() { tested.hide(); verify(view, times(1)).hide(); } |
### 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:
MorphNodeToolboxAction extends AbstractToolboxAction { @Override @SuppressWarnings("unchecked") public ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler, final String uuid, final MouseClickEvent event) { final String ssid = canvasHandler.getDiagram().getMetadata().getShapeSetId(); final Node<View<?>, Edge> sourceNode = (Node<View<?>, Edge>) CanvasLayoutUtils.getElement(canvasHandler, uuid).asNode(); clearSelectionEventEvent.fire(new CanvasClearSelectionEvent(canvasHandler)); final CommandResult<CanvasViolation> result = sessionCommandManager.execute(canvasHandler, commandFactory.morphNode(sourceNode, morphDefinition, targetDefinitionId, ssid)); if (CommandUtils.isError(result)) { LOGGER.log(Level.SEVERE, result.toString()); } else { CanvasLayoutUtils.fireElementSelectedEvent(selectionEvent, canvasHandler, uuid); } return this; } @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 testAction() { final MouseClickEvent event = mock(MouseClickEvent.class); ToolboxAction<AbstractCanvasHandler> cascade = tested.onMouseClick(canvasHandler, E_UUID, event); assertEquals(tested, cascade); verify(commandFactory, times(1)).morphNode(eq(element), eq(morphDefinition), eq(MORPH_TARGET_ID), eq(SSID_UUID)); verify(sessionCommandManager, times(1)).execute(eq(canvasHandler), eq(morphNodeCommand)); final ArgumentCaptor<CanvasSelectionEvent> eventArgumentCaptor = ArgumentCaptor.forClass(CanvasSelectionEvent.class); verify(canvasElementSelectedEvent, times(1)).fire(eventArgumentCaptor.capture()); final CanvasSelectionEvent eCaptured = eventArgumentCaptor.getValue(); assertEquals(E_UUID, eCaptured.getIdentifiers().iterator().next()); } |
### 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:
DeleteNodeToolboxAction implements ToolboxAction<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler, final String uuid, final MouseClickEvent event) { if (confirmDelete.test(this)) { final Metadata metadata = canvasHandler.getDiagram().getMetadata(); final Annotation qualifier = definitionUtils.getQualifier(metadata.getDefinitionSetId()); final CanvasCommandFactory<AbstractCanvasHandler> commandFactory = lookup(commandFactories, qualifier); final Node<?, Edge> node = CanvasLayoutUtils.getElement(canvasHandler, uuid).asNode(); clearSelectionEvent.fire(new CanvasClearSelectionEvent(canvasHandler)); sessionCommandManager.execute(canvasHandler, commandFactory.deleteNode(node)); } return this; } @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 testAction() { final MouseClickEvent event = mock(MouseClickEvent.class); final ToolboxAction<AbstractCanvasHandler> cascade = tested.onMouseClick(canvasHandler, E_UUID, event); assertEquals(tested, cascade); verify(commandFactory, times(1)).deleteNode(eq(element)); verify(sessionCommandManager, times(1)).execute(eq(canvasHandler), eq(deleteNodeCommand)); verify(clearSelectionEventEventSourceMock).fire(any(CanvasClearSelectionEvent.class)); }
@Test @SuppressWarnings("unchecked") public void testSkipAction() { this.tested = new DeleteNodeToolboxAction(translationService, sessionCommandManager, commandFactories, definitionUtils, action -> false, clearSelectionEventEventSourceMock); final MouseClickEvent event = mock(MouseClickEvent.class); final ToolboxAction<AbstractCanvasHandler> cascade = tested.onMouseClick(canvasHandler, E_UUID, event); assertEquals(tested, cascade); verify(sessionCommandManager, never()).execute(eq(canvasHandler), any(CanvasCommand.class)); verify(clearSelectionEventEventSourceMock, never()).fire(any(CanvasClearSelectionEvent.class)); } |
### 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:
DelegatingGridData implements GridData { @Override public boolean setVisibleSizeAndRefresh(final int width, final int height) { return delegate.setVisibleSizeAndRefresh(width, height); } DelegatingGridData(final DMNGridData delegate); @Override void moveRowTo(final int index,
final GridRow row); @Override void moveRowsTo(final int index,
final List<GridRow> rows); @Override void moveColumnTo(final int index,
final GridColumn<?> column); @Override void moveColumnsTo(final int index,
final List<GridColumn<?>> columns); @Override Range selectCell(final int rowIndex,
final int columnIndex); @Override Range selectCells(final int rowIndex,
final int columnIndex,
final int width,
final int height); @Override Range selectHeaderCell(final int headerRowIndex,
final int headerColumnIndex); @Override List<SelectedCell> getSelectedHeaderCells(); @Override Range setCell(final int rowIndex,
final int columnIndex,
final Supplier<GridCell<?>> cellSupplier); @Override Range setCellValue(final int rowIndex,
final int columnIndex,
final GridCellValue<?> value); @Override Range deleteCell(final int rowIndex,
final int columnIndex); @Override List<GridColumn<?>> getColumns(); @Override int getColumnCount(); @Override void appendColumn(final GridColumn<?> column); @Override void insertColumn(final int index,
final GridColumn<?> column); @Override void deleteColumn(final GridColumn<?> column); @Override List<GridRow> getRows(); @Override void expandCell(final int rowIndex,
final int columnIndex); @Override void collapseCell(final int rowIndex,
final int columnIndex); @Override void setColumnDraggingEnabled(final boolean enabled); @Override boolean isColumnDraggingEnabled(); @Override void setRowDraggingEnabled(final boolean enabled); @Override boolean isRowDraggingEnabled(); @Override void setMerged(final boolean isMerged); @Override boolean isMerged(); @Override void updateColumn(final int index,
final GridColumn<?> column); @Override void clearSelections(); @Override List<SelectedCell> getSelectedCells(); @Override SelectedCell getSelectedCellsOrigin(); @Override GridCell<?> getCell(final int rowIndex,
final int columnIndex); @Override void setHeaderRowCount(final int headerRowCount); @Override int getHeaderRowCount(); @Override int getRowCount(); @Override Range deleteRow(final int rowIndex); @Override void insertRow(final int rowIndex,
final GridRow row); @Override void appendRow(final GridRow row); @Override GridRow getRow(final int rowIndex); @Override boolean refreshWidth(); @Override boolean refreshWidth(final double currentWidth); @Override boolean setVisibleSizeAndRefresh(final int width, final int height); @Override int getVisibleWidth(); @Override int getVisibleHeight(); }### Answer:
@Test public void testSetVisibleSizeAndRefresh() { uiModel.setVisibleSizeAndRefresh(0, 1); verify(delegate).setVisibleSizeAndRefresh(eq(0), eq(1)); } |
### Question:
CreateNodeToolboxAction extends AbstractToolboxAction implements IsToolboxActionDraggable<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public ToolboxAction<AbstractCanvasHandler> onMoveStart(final AbstractCanvasHandler canvasHandler, final String uuid, final MouseMoveEvent event) { final Node<View<?>, Edge> sourceNode = getSourceNode(canvasHandler, uuid); final Edge<ViewConnector<?>, Node> connector = buildEdge(); final Node<View<?>, Edge> targetNode = buildTargetNode(); nodeProxy .setTargetNode(targetNode) .setEdge(connector) .setSourceNode(sourceNode) .setCanvasHandler(canvasHandler) .start(event); 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 testOnMoveStart() { final MouseMoveEvent event = mock(MouseMoveEvent.class); when(event.getX()).thenReturn(100d); when(event.getY()).thenReturn(500d); tested.onMoveStart(canvasHandler, NODE_UUID, event); verify(nodeProxy, times(1)).setCanvasHandler(eq(canvasHandler)); verify(nodeProxy, times(1)).setSourceNode(eq(element)); verify(nodeProxy, times(1)).setEdge(eq(edge)); verify(nodeProxy, times(1)).setTargetNode(eq(targetNode)); verify(nodeProxy, times(1)).start(eq(event)); } |
### 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 { @SuppressWarnings("unchecked") public static void applyConnections(final Edge<? extends ViewConnector<?>, Node> edge, final AbstractCanvasHandler canvasHandler, final MutationContext mutationContext) { final Canvas<?> canvas = canvasHandler.getCanvas(); final Node sourceNode = edge.getSourceNode(); final Node targetNode = edge.getTargetNode(); final Shape<?> source = sourceNode != null ? canvas.getShape(sourceNode.getUUID()) : null; final Shape<?> target = targetNode != null ? canvas.getShape(targetNode.getUUID()) : null; EdgeShape connector = (EdgeShape) canvas.getShape(edge.getUUID()); if (connector != null) { connector.applyConnections(edge, source != null ? source.getShapeView() : null, target != null ? target.getShapeView() : null, mutationContext); } updateEdgeConnections(edge, canvasHandler); } @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 @SuppressWarnings("unchecked") public void testApplyConnections() { final Shape startNodeShape = mock(Shape.class); final ShapeView startNodeShapeView = mock(ShapeView.class); final Shape intermNodeShape = mock(Shape.class); final ShapeView intermNodeShapeView = mock(ShapeView.class); final EdgeShape edge1EdgeShape = mock(EdgeShape.class); when(canvas.getShape(eq(instance2.startNode.getUUID()))).thenReturn(startNodeShape); when(canvas.getShape(eq(instance2.intermNode.getUUID()))).thenReturn(intermNodeShape); when(canvas.getShape(eq(instance2.edge1.getUUID()))).thenReturn(edge1EdgeShape); when(startNodeShape.getShapeView()).thenReturn(startNodeShapeView); when(intermNodeShape.getShapeView()).thenReturn(intermNodeShapeView); when(edge1EdgeShape.getShapeView()).thenReturn(edge1ShapeView); ShapeUtils.applyConnections(instance2.edge1, canvasHandler, MutationContext.STATIC); verify(edge1EdgeShape, times(1)).applyConnections(eq(instance2.edge1), eq(startNodeShapeView), eq(intermNodeShapeView), eq(MutationContext.STATIC)); } |
### Question:
DelegatingGridData implements GridData { @Override public int getVisibleWidth() { return delegate.getVisibleWidth(); } DelegatingGridData(final DMNGridData delegate); @Override void moveRowTo(final int index,
final GridRow row); @Override void moveRowsTo(final int index,
final List<GridRow> rows); @Override void moveColumnTo(final int index,
final GridColumn<?> column); @Override void moveColumnsTo(final int index,
final List<GridColumn<?>> columns); @Override Range selectCell(final int rowIndex,
final int columnIndex); @Override Range selectCells(final int rowIndex,
final int columnIndex,
final int width,
final int height); @Override Range selectHeaderCell(final int headerRowIndex,
final int headerColumnIndex); @Override List<SelectedCell> getSelectedHeaderCells(); @Override Range setCell(final int rowIndex,
final int columnIndex,
final Supplier<GridCell<?>> cellSupplier); @Override Range setCellValue(final int rowIndex,
final int columnIndex,
final GridCellValue<?> value); @Override Range deleteCell(final int rowIndex,
final int columnIndex); @Override List<GridColumn<?>> getColumns(); @Override int getColumnCount(); @Override void appendColumn(final GridColumn<?> column); @Override void insertColumn(final int index,
final GridColumn<?> column); @Override void deleteColumn(final GridColumn<?> column); @Override List<GridRow> getRows(); @Override void expandCell(final int rowIndex,
final int columnIndex); @Override void collapseCell(final int rowIndex,
final int columnIndex); @Override void setColumnDraggingEnabled(final boolean enabled); @Override boolean isColumnDraggingEnabled(); @Override void setRowDraggingEnabled(final boolean enabled); @Override boolean isRowDraggingEnabled(); @Override void setMerged(final boolean isMerged); @Override boolean isMerged(); @Override void updateColumn(final int index,
final GridColumn<?> column); @Override void clearSelections(); @Override List<SelectedCell> getSelectedCells(); @Override SelectedCell getSelectedCellsOrigin(); @Override GridCell<?> getCell(final int rowIndex,
final int columnIndex); @Override void setHeaderRowCount(final int headerRowCount); @Override int getHeaderRowCount(); @Override int getRowCount(); @Override Range deleteRow(final int rowIndex); @Override void insertRow(final int rowIndex,
final GridRow row); @Override void appendRow(final GridRow row); @Override GridRow getRow(final int rowIndex); @Override boolean refreshWidth(); @Override boolean refreshWidth(final double currentWidth); @Override boolean setVisibleSizeAndRefresh(final int width, final int height); @Override int getVisibleWidth(); @Override int getVisibleHeight(); }### Answer:
@Test public void testGetVisibleWidth() { uiModel.getVisibleWidth(); verify(delegate, times(1)).getVisibleWidth(); } |
### Question:
ShapeUtils { @SuppressWarnings("unchecked") public static void moveViewConnectorsToTop(final AbstractCanvasHandler canvasHandler, final Node<?, Edge> node) { final Set<String> connectorIds = new HashSet<>(); appendViewConnectorIds(connectorIds, node); new ChildrenTraverseProcessorImpl(new TreeWalkTraverseProcessorImpl()) .setRootUUID(node.getUUID()) .traverse(canvasHandler.getGraphIndex().getGraph(), new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() { @Override public boolean startNodeTraversal(final List<Node<View, Edge>> parents, final Node<View, Edge> childNode) { appendViewConnectorIds(connectorIds, childNode); return true; } }); connectorIds.forEach(id -> moveShapeToTop(canvasHandler, id)); } @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 @SuppressWarnings("unchecked") public void testMoveViewConnectorsToTop() { ShapeUtils.moveViewConnectorsToTop(canvasHandler, instance2.parentNode); verify(edge1ShapeView, times(1)).moveToTop(); verify(edge2ShapeView, times(1)).moveToTop(); } |
### 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 { @SuppressWarnings("unchecked") public String generate(final SafeUri svgUri) { return generate(svgUri, Collections.EMPTY_LIST, Collections.EMPTY_LIST); } 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 testNoProcessing() { assertEquals(SVG_CONTENT, tested.generate(simpleUri)); }
@Test public void testSingle() { final String singleSvgContent = tested.generate(taskUri); assertTrue(singleSvgContent.contains("<svg id=\"Layer_Main\"")); assertFalse(singleSvgContent.contains("<\\?xml")); assertFalse(singleSvgContent.contains("<use")); }
@Test public void testComposite() { final List<SafeUri> defs = Arrays.asList(taskUserUri, taskScriptUri); final List<String> defIds = Arrays.asList("Layer_2", "Layer_3"); String compositeSvgContent = tested.generate(taskUri, defs, defIds); assertFalse(compositeSvgContent.contains("<\\?xml")); assertEquals(97, compositeSvgContent.indexOf("width=\"448\"")); assertEquals(109, compositeSvgContent.indexOf("height=\"448\"")); assertEquals(122, compositeSvgContent.indexOf("viewBox=\"0 0 448 448\"")); assertTrue(compositeSvgContent.contains("viewBox=\"0 0 448 448\"")); assertTrue(compositeSvgContent.contains("<svg id=\"Layer_Main\"")); assertTrue(compositeSvgContent.contains("<svg id=\"Layer_2\"")); assertTrue(compositeSvgContent.contains("<svg id=\"Layer_3\"")); assertTrue(compositeSvgContent.contains("<use xlink:href=\"#Layer_2\"")); assertTrue(compositeSvgContent.contains("<use xlink:href=\"#Layer_3\"")); }
@Test public void testFiltered() { String filteredSvgContent = tested.generate(taskUri, Arrays.asList(taskScriptUri, taskUserUri), Arrays.asList("Layer_3")); assertFalse(filteredSvgContent.contains("<\\?xml")); assertEquals(97, filteredSvgContent.indexOf("width=\"448\"")); assertEquals(109, filteredSvgContent.indexOf("height=\"448\"")); assertEquals(122, filteredSvgContent.indexOf("viewBox=\"0 0 448 448\"")); assertTrue(filteredSvgContent.contains("<svg id=\"Layer_Main\"")); assertTrue(filteredSvgContent.contains("<svg id=\"Layer_2\"")); assertTrue(filteredSvgContent.contains("<svg id=\"Layer_3\"")); assertFalse(filteredSvgContent.contains("<use xlink:href=\"#Layer_2\"")); assertTrue(filteredSvgContent.contains("<use xlink:href=\"#Layer_3\"")); } |
### 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:
DelegatingGridData implements GridData { @Override public int getVisibleHeight() { return delegate.getVisibleHeight(); } DelegatingGridData(final DMNGridData delegate); @Override void moveRowTo(final int index,
final GridRow row); @Override void moveRowsTo(final int index,
final List<GridRow> rows); @Override void moveColumnTo(final int index,
final GridColumn<?> column); @Override void moveColumnsTo(final int index,
final List<GridColumn<?>> columns); @Override Range selectCell(final int rowIndex,
final int columnIndex); @Override Range selectCells(final int rowIndex,
final int columnIndex,
final int width,
final int height); @Override Range selectHeaderCell(final int headerRowIndex,
final int headerColumnIndex); @Override List<SelectedCell> getSelectedHeaderCells(); @Override Range setCell(final int rowIndex,
final int columnIndex,
final Supplier<GridCell<?>> cellSupplier); @Override Range setCellValue(final int rowIndex,
final int columnIndex,
final GridCellValue<?> value); @Override Range deleteCell(final int rowIndex,
final int columnIndex); @Override List<GridColumn<?>> getColumns(); @Override int getColumnCount(); @Override void appendColumn(final GridColumn<?> column); @Override void insertColumn(final int index,
final GridColumn<?> column); @Override void deleteColumn(final GridColumn<?> column); @Override List<GridRow> getRows(); @Override void expandCell(final int rowIndex,
final int columnIndex); @Override void collapseCell(final int rowIndex,
final int columnIndex); @Override void setColumnDraggingEnabled(final boolean enabled); @Override boolean isColumnDraggingEnabled(); @Override void setRowDraggingEnabled(final boolean enabled); @Override boolean isRowDraggingEnabled(); @Override void setMerged(final boolean isMerged); @Override boolean isMerged(); @Override void updateColumn(final int index,
final GridColumn<?> column); @Override void clearSelections(); @Override List<SelectedCell> getSelectedCells(); @Override SelectedCell getSelectedCellsOrigin(); @Override GridCell<?> getCell(final int rowIndex,
final int columnIndex); @Override void setHeaderRowCount(final int headerRowCount); @Override int getHeaderRowCount(); @Override int getRowCount(); @Override Range deleteRow(final int rowIndex); @Override void insertRow(final int rowIndex,
final GridRow row); @Override void appendRow(final GridRow row); @Override GridRow getRow(final int rowIndex); @Override boolean refreshWidth(); @Override boolean refreshWidth(final double currentWidth); @Override boolean setVisibleSizeAndRefresh(final int width, final int height); @Override int getVisibleWidth(); @Override int getVisibleHeight(); }### Answer:
@Test public void testGetVisibleHeight() { uiModel.getVisibleHeight(); verify(delegate, times(1)).getVisibleHeight(); } |
### 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:
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 applyConnections(final Edge<ViewConnector<W>, Node> element, final ShapeView<?> source, final ShapeView<?> target, final MutationContext mutationContext) { final ViewConnector connectionContent = element.getContent(); final Connection sourceConnection = (Connection) connectionContent.getSourceConnection().orElse(null); final Connection targetConnection = (Connection) connectionContent.getTargetConnection().orElse(null); final IsConnector shapeView = (IsConnector) getShapeView(); shapeView.connect(source, sourceConnection, target, targetConnection); } 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 testApplyConnections() { final Object def = mock(Object.class); final Edge<ViewConnector<Object>, Node> edge = new EdgeImpl<>("uuid1"); final ViewConnectorImpl<Object> content = new ViewConnectorImpl<>(def, BOUNDS); Connection sourceConnection = mock(Connection.class); Connection targetConnection = mock(Connection.class); content.setSourceConnection(sourceConnection); content.setTargetConnection(targetConnection); edge.setContent(content); final ShapeView<?> source = mock(ShapeView.class); final ShapeView<?> target = mock(ShapeView.class); tested.applyConnections(edge, source, target, MutationContext.STATIC); verify(((IsConnector) shapeView), times(1)).connect(eq(source), eq(sourceConnection), eq(target), eq(targetConnection)); }
@Test @SuppressWarnings("unchecked") public void testApplyConnectionsEvenNoSourceOrTarget() { final Object def = mock(Object.class); final Edge<ViewConnector<Object>, Node> edge = new EdgeImpl<>("uuid1"); final ViewConnectorImpl<Object> content = new ViewConnectorImpl<>(def, BOUNDS); Connection sourceConnection = mock(Connection.class); Connection targetConnection = mock(Connection.class); content.setSourceConnection(sourceConnection); content.setTargetConnection(targetConnection); edge.setContent(content); tested.applyConnections(edge, null, null, MutationContext.STATIC); verify(((IsConnector) shapeView), times(1)).connect(eq(null), eq(sourceConnection), eq(null), eq(targetConnection)); } |
### 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 @SuppressWarnings("unchecked") public <V> void execute(final Callback<V> callback) { checkNotNull("callback", callback); final CommandResult<CanvasViolation> result = getSession() .getCommandManager() .execute(getSession().getCanvasHandler(), canvasCommandFactory.clearCanvas()); if (!CommandUtils.isError(result)) { cleanSessionRegistry(); commandExecutedEvent.fire(new ClearSessionCommandExecutedEvent(this, getSession())); callback.onSuccess(); } else { callback.onError((V) result); } } 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 @SuppressWarnings("unchecked") public void testExecuteSuccess() { when(sessionCommandManager.execute(canvasHandler, clearCanvasCommand)).thenReturn(null); command.execute(callback); verify(sessionCommandManager, times(1)).execute(canvasHandler, clearCanvasCommand); verify(commandRegistry, times(1)).clear(); verify(callback, times(1)).onSuccess(); verify(commandExecutedEvent, times(1)).fire(commandExecutedEventCaptor.capture()); assertEquals(session, commandExecutedEventCaptor.getValue().getClientSession()); assertEquals(command, commandExecutedEventCaptor.getValue().getExecutedCommand()); }
@Test @SuppressWarnings("unchecked") public void testExecuteWithErrors() { when(sessionCommandManager.execute(canvasHandler, clearCanvasCommand)).thenReturn(commandResult); when(commandResult.getType()).thenReturn(CommandResult.Type.ERROR); command.execute(callback); verify(sessionCommandManager, times(1)).execute(canvasHandler, clearCanvasCommand); verify(commandRegistry, never()).clear(); verify(callback, times(1)).onError(commandResult); verify(commandExecutedEvent, never()).fire(commandExecutedEventCaptor.capture()); } |
### 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:
DMNMarshallerImportsHelperStandaloneImpl implements DMNMarshallerImportsHelperStandalone { @Override public Optional<InputStream> loadPath(final Path path) { try { return Optional.ofNullable(ioService.newInputStream(convertPath(path))); } catch (final Exception e) { return Optional.empty(); } } DMNMarshallerImportsHelperStandaloneImpl(); @Inject DMNMarshallerImportsHelperStandaloneImpl(final DMNPathsHelper pathsHelper,
final WorkspaceProjectService projectService,
final DMNMarshaller marshaller,
final DMNIOHelper dmnIOHelper,
final PMMLIncludedDocumentFactory pmmlDocumentFactory,
final @Named("ioStrategy") IOService ioService); @Override Map<Import, Definitions> getImportDefinitions(final Metadata metadata,
final List<Import> imports); @Override Map<Import, PMMLDocumentMetadata> getPMMLDocuments(final Metadata metadata,
final List<Import> imports); @Override Map<Import, String> getImportXML(final Metadata metadata,
final List<Import> imports); @Override Path getDMNModelPath(final Metadata metadata,
final String modelNamespace,
final String modelName); @Override List<DRGElement> getImportedDRGElements(final Map<Import, Definitions> importDefinitions); @Override List<ItemDefinition> getImportedItemDefinitions(final Map<Import, Definitions> importDefinitions); @Override List<ItemDefinition> getImportedItemDefinitionsByNamespace(final WorkspaceProject workspaceProject,
final String modelName,
final String namespace); @Override Optional<InputStream> loadPath(final Path path); static final QName NAMESPACE; }### Answer:
@Test public void testLoadPath() { final Path path = mock(Path.class); final org.uberfire.java.nio.file.Path nioPath = mock(org.uberfire.java.nio.file.Path.class); final String expectedContent = "<dmn/>"; final byte[] contentBytes = expectedContent.getBytes(); doReturn(nioPath).when(helper).convertPath(path); when(ioService.newInputStream(nioPath)).thenReturn(new ByteArrayInputStream(contentBytes)); final Optional<InputStream> inputStream = helper.loadPath(path); assertTrue(inputStream.isPresent()); assertEquals(expectedContent, new Scanner(new InputStreamReader(inputStream.get())).next()); } |
### 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 CopySelectionSessionCommand getInstanceCopy( final Event<?> commandExecutedEvent, SessionManager sessionManager) { final ClientSession currentSession = sessionManager.getCurrentSession(); if (!copySessionInstances.containsKey(currentSession)) { final CopySelectionSessionCommand copySelectionSessionCommand = new CopySelectionSessionCommand((Event<CopySelectionSessionCommandExecutedEvent>) commandExecutedEvent, sessionManager); return copySelectionSessionCommand; } final CopySelectionSessionCommand copySelectionSessionCommand = copySessionInstances.get(currentSession); return copySelectionSessionCommand; } 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 testGetInstancesCopy() { final CopySelectionSessionCommand copySelectionSessionCommand = new CopySelectionSessionCommand(null, sessionManager); final CopySelectionSessionCommand instanceCopy = SessionSingletonCommandsFactory.getInstanceCopy(null, sessionManager); assertEquals(copySelectionSessionCommand, instanceCopy); when(sessionManager.getCurrentSession()).thenReturn(session2); final CopySelectionSessionCommand copySelectionSessionCommand2 = new CopySelectionSessionCommand(null, sessionManager); final CopySelectionSessionCommand instanceCopy2 = SessionSingletonCommandsFactory.getInstanceCopy(null, sessionManager); assertEquals(copySelectionSessionCommand2, instanceCopy2); }
@Test public void testGetInstancesOnFetchCopy() { final CopySelectionSessionCommand instanceCopy = SessionSingletonCommandsFactory.getInstanceCopy(null, sessionManager); final CopySelectionSessionCommand instanceCopy2 = SessionSingletonCommandsFactory.getInstanceCopy(null, sessionManager); assertEquals(instanceCopy, instanceCopy2); }
@Test(expected = IllegalStateException.class) public void testGetInstancesOnFetchCopyError() { final CopySelectionSessionCommand instanceCopy = SessionSingletonCommandsFactory.getInstanceCopy(null, sessionManager); final CopySelectionSessionCommand instanceCopy2 = new CopySelectionSessionCommand(null, 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:
CopySelectionSessionCommand extends AbstractSelectionAwareSessionCommand<EditorSession> { @Override public <V> void execute(final Callback<V> callback) { if (getSession() != null && null != getSession().getSelectionControl()) { try { final SelectionControl<AbstractCanvasHandler, Element> selectionControl = getSession().getSelectionControl(); clipboardControl.set(selectionControl.getSelectedItems().stream() .map(this::getElement) .toArray(Element[]::new)); final Set<String> clipboardNodes = clipboardControl.getElements().stream() .filter(element -> element instanceof Node) .map(Element::getUUID) .collect(Collectors.toSet()); clipboardControl.getEdgeMap().clear(); clipboardControl.getEdgeMap().putAll(clipboardControl.getElements().stream() .filter(element -> element instanceof Edge) .map(edge -> (Edge) edge) .collect(Collectors.toList()).stream() .filter(edge -> clipboardNodes.contains(edge.getSourceNode().getUUID()) && clipboardNodes.contains(edge.getTargetNode().getUUID())) .collect(Collectors.toMap(Edge::getUUID, edge -> clipboardControl.buildNewEdgeClipboard(edge.getSourceNode().getUUID(), (Connection) ((ViewConnector) edge.getContent()).getSourceConnection().orElse(null), edge.getTargetNode().getUUID(), (Connection) ((ViewConnector) edge.getContent()).getTargetConnection().orElse(null)) ))); commandExecutedEvent.fire(new CopySelectionSessionCommandExecutedEvent(this, getSession())); callback.onSuccess(); } catch (Exception e) { LOGGER.severe("Error on copy selection." + e.getMessage()); return; } } } CopySelectionSessionCommand(); @Inject CopySelectionSessionCommand(final Event<CopySelectionSessionCommandExecutedEvent> commandExecutedEvent, final SessionManager sessionManager); static CopySelectionSessionCommand getInstance(SessionManager sessionManager); static CopySelectionSessionCommand getInstance(final Event<CopySelectionSessionCommandExecutedEvent> commandExecutedEvent, SessionManager sessionManager); @Override void bind(final EditorSession session); @Override boolean accepts(final ClientSession session); @Override void execute(final Callback<V> callback); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { copySelectionSessionCommand.bind(session); copySelectionSessionCommand.execute(callback); verify(selectionControl, atLeastOnce()).getSelectedItems(); verify(clipboardControl, times(1)).set(node); verify(callback, times(1)).onSuccess(); verify(commandExecutedEvent, times(1)).fire(eventArgumentCaptor.capture()); assertEquals(session, eventArgumentCaptor.getValue().getClientSession()); assertEquals(copySelectionSessionCommand, eventArgumentCaptor.getValue().getExecutedCommand()); reset(callback); when(selectionControl.getSelectedItems()).thenThrow(new RuntimeException()); copySelectionSessionCommand.execute(callback); verify(callback, never()).onSuccess(); } |
### 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:
CutSelectionSessionCommand extends AbstractSelectionAwareSessionCommand<EditorSession> { @Override public <V> void execute(Callback<V> callback) { copySelectionSessionCommand.execute(new Callback<V>() { @Override public void onSuccess() { deleteSelectionSessionCommand.execute(callback); Command<AbstractCanvasHandler, CanvasViolation> command = getSession().getCommandRegistry().peek(); clipboardControl.setRollbackCommand(command); commandExecutedEvent.fire(new CutSelectionSessionCommandExecutedEvent(CutSelectionSessionCommand.this, CutSelectionSessionCommand.this.getSession())); } @Override public void onError(V error) { LOGGER.severe("Error on cut selection." + String.valueOf(error)); callback.onError(error); } }); } protected CutSelectionSessionCommand(); @Inject CutSelectionSessionCommand(final Event<CutSelectionSessionCommandExecutedEvent> commandExecutedEvent,
final SessionManager sessionManager); @Override void bind(final EditorSession session); void setCopySelectionSessionCommand(CopySelectionSessionCommand copySelectionSessionCommand); @Override boolean accepts(final ClientSession session); @Override void execute(Callback<V> callback); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { cutSelectionSessionCommand.bind(session); CopySelectionSessionCommand.getInstance(sessionManager).bind(session); cutSelectionSessionCommand.setCopySelectionSessionCommand(copySelectionSessionCommand); cutSelectionSessionCommand.execute(mainCallback); ArgumentCaptor<ClientSessionCommand.Callback> callbackArgumentCaptor = ArgumentCaptor.forClass(ClientSessionCommand.Callback.class); verify(copySelectionSessionCommand).execute(callbackArgumentCaptor.capture()); callbackArgumentCaptor.getValue().onSuccess(); verify(session.getCommandRegistry(), atLeastOnce()).peek(); verify(clipboardControl, atLeastOnce()).setRollbackCommand(deleteNodeCommand); verify(commandExecutedEvent, times(1)).fire(commandExecutedEventCaptor.capture()); assertEquals(session, commandExecutedEventCaptor.getValue().getClientSession()); assertEquals(cutSelectionSessionCommand, commandExecutedEventCaptor.getValue().getExecutedCommand()); Object error = new Object(); callbackArgumentCaptor.getValue().onError(error); verify(mainCallback, times(1)).onError(error); } |
### 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:
ManagedSession extends AbstractSession<AbstractCanvas, AbstractCanvasHandler> { @Override public void init(final Metadata metadata, final Command callback) { if (null != canvas) { throw new IllegalStateException("Session is already loaded!"); } sessionLoader.load(metadata, prefs -> { final Annotation qualifier = definitionUtils.getQualifier(metadata.getDefinitionSetId()); canvas = lookup(canvasInstances, qualifier); canvasHandler = lookup(canvasHandlerInstances, qualifier); canvasControlRegistrationEntries .forEach(entry -> registerCanvasControlEntry(entry, qualifier)); canvasHandlerControlRegistrationEntries .forEach(entry -> registerCanvasHandlerControlEntry(entry, qualifier)); callback.execute(); }, throwable -> { if (LogConfiguration.loggingIsEnabled()) { LOGGER.log(Level.SEVERE, "An error was produced during StunnerPreferences initialization.", throwable); } throw new RuntimeException(throwable); }); } @Inject ManagedSession(final DefinitionUtils definitionUtils,
final SessionLoader sessionLoader,
final @Any ManagedInstance<AbstractCanvas> canvasInstances,
final @Any ManagedInstance<AbstractCanvasHandler> canvasHandlerInstances,
final @Any ManagedInstance<CanvasControl<AbstractCanvas>> canvasControlInstances,
final @Any ManagedInstance<CanvasControl<AbstractCanvasHandler>> canvasHandlerControlInstances); @SuppressWarnings("unchecked") ManagedSession registerCanvasControl(final Class<? extends CanvasControl> type); @SuppressWarnings("unchecked") ManagedSession registerCanvasControl(final Class<? extends CanvasControl> type,
final Class<? extends Annotation> qualifier); @SuppressWarnings("unchecked") ManagedSession registerCanvasHandlerControl(final Class<? extends CanvasControl> type); @SuppressWarnings("unchecked") ManagedSession registerCanvasHandlerControl(final Class<? extends CanvasControl> type,
final Class<? extends Annotation> qualifier); ManagedSession isControlActive(final Predicate<Class<? extends CanvasControl>> predicate); ManagedSession onCanvasControlRegistered(final Consumer<CanvasControl<AbstractCanvas>> c); ManagedSession onCanvasControlDestroyed(final Consumer<CanvasControl<AbstractCanvas>> c); ManagedSession onCanvasHandlerControlRegistered(final Consumer<CanvasControl<AbstractCanvasHandler>> c); ManagedSession onCanvasHandlerControlDestroyed(final Consumer<CanvasControl<AbstractCanvasHandler>> c); @Override void init(final Metadata metadata,
final Command callback); @Override void open(); @Override void destroy(); @Override String getSessionUUID(); @Override AbstractCanvas getCanvas(); @Override AbstractCanvasHandler getCanvasHandler(); CanvasControl<AbstractCanvas> getCanvasControl(final Class<? extends CanvasControl> type); CanvasControl<AbstractCanvasHandler> getCanvasHandlerControl(final Class<? extends CanvasControl> type); static Annotation buildQualifier(final Class<? extends Annotation> type); }### Answer:
@Test @SuppressWarnings("unchecked") public void testInit() { Command callback = mock(Command.class); Consumer<CanvasControl<AbstractCanvas>> canvasControlConsumer = mock(Consumer.class); Consumer<CanvasControl<AbstractCanvasHandler>> canvasHandlerControlConsumer = mock(Consumer.class); tested.registerCanvasControl(SomeTestControl.class) .registerCanvasHandlerControl(SomeTestControl.class) .onCanvasControlRegistered(canvasControlConsumer) .onCanvasHandlerControlRegistered(canvasHandlerControlConsumer) .init(metadata, callback); assertEquals(canvas, tested.getCanvas()); assertEquals(canvasHandler, tested.getCanvasHandler()); assertEquals(canvasControl, tested.getCanvasControls().get(0)); assertEquals(canvasHandlerControl, tested.getCanvasHandlerControls().get(0)); verify(sessionLoader, times(1)).load(eq(metadata), any(ParameterizedCommand.class), any(ParameterizedCommand.class)); verify(canvasInstances, times(1)).select(eq(qualifier)); verify(canvasHandlerInstances, times(1)).select(eq(qualifier)); verify(canvasControlInstances, times(1)).select(eq(SomeTestControl.class), eq(qualifier)); verify(canvasHandlerControlInstances, times(1)).select(eq(SomeTestControl.class), eq(qualifier)); verify(canvasControlConsumer, times(1)).accept(eq(canvasControl)); verify(canvasHandlerControlConsumer, times(1)).accept(eq(canvasHandlerControl)); verify(callback, times(1)).execute(); } |
### Question:
ManagedSession extends AbstractSession<AbstractCanvas, AbstractCanvasHandler> { @Override public void open() { if (null == shapeListener) { shapeListener = new DefaultCanvasShapeListener(canvasControls); elementListener = new DefaultCanvasElementListener(canvasHandlerControls); registerListeners(); enableControls(); } } @Inject ManagedSession(final DefinitionUtils definitionUtils,
final SessionLoader sessionLoader,
final @Any ManagedInstance<AbstractCanvas> canvasInstances,
final @Any ManagedInstance<AbstractCanvasHandler> canvasHandlerInstances,
final @Any ManagedInstance<CanvasControl<AbstractCanvas>> canvasControlInstances,
final @Any ManagedInstance<CanvasControl<AbstractCanvasHandler>> canvasHandlerControlInstances); @SuppressWarnings("unchecked") ManagedSession registerCanvasControl(final Class<? extends CanvasControl> type); @SuppressWarnings("unchecked") ManagedSession registerCanvasControl(final Class<? extends CanvasControl> type,
final Class<? extends Annotation> qualifier); @SuppressWarnings("unchecked") ManagedSession registerCanvasHandlerControl(final Class<? extends CanvasControl> type); @SuppressWarnings("unchecked") ManagedSession registerCanvasHandlerControl(final Class<? extends CanvasControl> type,
final Class<? extends Annotation> qualifier); ManagedSession isControlActive(final Predicate<Class<? extends CanvasControl>> predicate); ManagedSession onCanvasControlRegistered(final Consumer<CanvasControl<AbstractCanvas>> c); ManagedSession onCanvasControlDestroyed(final Consumer<CanvasControl<AbstractCanvas>> c); ManagedSession onCanvasHandlerControlRegistered(final Consumer<CanvasControl<AbstractCanvasHandler>> c); ManagedSession onCanvasHandlerControlDestroyed(final Consumer<CanvasControl<AbstractCanvasHandler>> c); @Override void init(final Metadata metadata,
final Command callback); @Override void open(); @Override void destroy(); @Override String getSessionUUID(); @Override AbstractCanvas getCanvas(); @Override AbstractCanvasHandler getCanvasHandler(); CanvasControl<AbstractCanvas> getCanvasControl(final Class<? extends CanvasControl> type); CanvasControl<AbstractCanvasHandler> getCanvasHandlerControl(final Class<? extends CanvasControl> type); static Annotation buildQualifier(final Class<? extends Annotation> type); }### Answer:
@Test @SuppressWarnings("unchecked") public void testOpen() { tested.registerCanvasControl(SomeTestControl.class) .registerCanvasHandlerControl(SomeTestControl.class) .init(metadata, mock(Command.class)); tested.open(); verify(canvas, times(1)).addRegistrationListener(any(CanvasShapeListener.class)); verify(canvasHandler, times(1)).addRegistrationListener(any(CanvasElementListener.class)); verify(canvasControl, times(1)).init(eq(canvas)); verify(canvasHandlerControl, times(1)).init(eq(canvasHandler)); } |
### Question:
ManagedSession extends AbstractSession<AbstractCanvas, AbstractCanvasHandler> { @Override public void destroy() { sessionLoader.destroy(); removeListeners(); canvasControls.forEach(this::destroyCanvasControl); canvasControls.clear(); canvasControlTypes.clear(); canvasHandlerControls.forEach(this::destroyCanvasHandlerControl); canvasHandlerControls.clear(); canvasHandlerControlTypes.clear(); canvasControlInstances.destroyAll(); canvasHandlerControlInstances.destroyAll(); canvasHandler.destroy(); canvasInstances.destroyAll(); canvasHandlerInstances.destroyAll(); canvas = null; canvasHandler = null; shapeListener = null; elementListener = null; canvasControlRegistered = null; canvasControlDestroyed = null; canvasHandlerControlRegistered = null; canvasHandlerControlDestroyed = null; } @Inject ManagedSession(final DefinitionUtils definitionUtils,
final SessionLoader sessionLoader,
final @Any ManagedInstance<AbstractCanvas> canvasInstances,
final @Any ManagedInstance<AbstractCanvasHandler> canvasHandlerInstances,
final @Any ManagedInstance<CanvasControl<AbstractCanvas>> canvasControlInstances,
final @Any ManagedInstance<CanvasControl<AbstractCanvasHandler>> canvasHandlerControlInstances); @SuppressWarnings("unchecked") ManagedSession registerCanvasControl(final Class<? extends CanvasControl> type); @SuppressWarnings("unchecked") ManagedSession registerCanvasControl(final Class<? extends CanvasControl> type,
final Class<? extends Annotation> qualifier); @SuppressWarnings("unchecked") ManagedSession registerCanvasHandlerControl(final Class<? extends CanvasControl> type); @SuppressWarnings("unchecked") ManagedSession registerCanvasHandlerControl(final Class<? extends CanvasControl> type,
final Class<? extends Annotation> qualifier); ManagedSession isControlActive(final Predicate<Class<? extends CanvasControl>> predicate); ManagedSession onCanvasControlRegistered(final Consumer<CanvasControl<AbstractCanvas>> c); ManagedSession onCanvasControlDestroyed(final Consumer<CanvasControl<AbstractCanvas>> c); ManagedSession onCanvasHandlerControlRegistered(final Consumer<CanvasControl<AbstractCanvasHandler>> c); ManagedSession onCanvasHandlerControlDestroyed(final Consumer<CanvasControl<AbstractCanvasHandler>> c); @Override void init(final Metadata metadata,
final Command callback); @Override void open(); @Override void destroy(); @Override String getSessionUUID(); @Override AbstractCanvas getCanvas(); @Override AbstractCanvasHandler getCanvasHandler(); CanvasControl<AbstractCanvas> getCanvasControl(final Class<? extends CanvasControl> type); CanvasControl<AbstractCanvasHandler> getCanvasHandlerControl(final Class<? extends CanvasControl> type); static Annotation buildQualifier(final Class<? extends Annotation> type); }### Answer:
@Test @SuppressWarnings("unchecked") public void testDestroy() { tested.registerCanvasControl(SomeTestControl.class) .registerCanvasHandlerControl(SomeTestControl.class) .init(metadata, mock(Command.class)); tested.open(); tested.destroy(); assertNull(tested.getCanvas()); assertNull(tested.getCanvasHandler()); assertTrue(tested.getCanvasControls().isEmpty()); assertTrue(tested.getCanvasHandlerControls().isEmpty()); verify(canvas, times(1)).removeRegistrationListener(any(CanvasShapeListener.class)); verify(canvasHandler, times(1)).removeRegistrationListener(any(CanvasElementListener.class)); verify(canvasHandler, times(1)).destroy(); verify(canvasControl, times(1)).destroy(); verify(canvasHandlerControl, times(1)).destroy(); verify(canvasControlInstances, times(1)).destroyAll(); verify(canvasHandlerControlInstances, times(1)).destroyAll(); verify(canvasControlInstances, times(1)).destroyAll(); verify(canvasHandlerControlInstances, times(1)).destroyAll(); } |
### 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 init(final Metadata metadata, final Command callback) { init(s -> s.registerCanvasControl(MediatorsControl.class) .registerCanvasHandlerControl(SelectionControl.class, MultipleSelection.class) .registerCanvasHandlerControl(ResizeControl.class) .registerCanvasHandlerControl(ConnectionAcceptorControl.class) .registerCanvasHandlerControl(ContainmentAcceptorControl.class) .registerCanvasHandlerControl(DockingAcceptorControl.class) .registerCanvasHandlerControl(CanvasInlineTextEditorControl.class) .registerCanvasHandlerControl(LocationControl.class) .registerCanvasHandlerControl(ToolboxControl.class) .registerCanvasHandlerControl(ElementBuilderControl.class, Observer.class) .registerCanvasHandlerControl(NodeBuilderControl.class) .registerCanvasHandlerControl(EdgeBuilderControl.class) .registerCanvasHandlerControl(AbstractCanvasShortcutsControlImpl.class) .registerCanvasControl(KeyboardControl.class) .registerCanvasControl(ClipboardControl.class) .registerCanvasHandlerControl(ControlPointControl.class), metadata, callback); } @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 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)).registerCanvasHandlerControl(eq(ResizeControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(ConnectionAcceptorControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(ContainmentAcceptorControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(DockingAcceptorControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(CanvasInlineTextEditorControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(LocationControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(ToolboxControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(ElementBuilderControl.class), eq(Observer.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(NodeBuilderControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(EdgeBuilderControl.class)); verify(managedSession, times(1)).registerCanvasControl(eq(KeyboardControl.class)); verify(managedSession, times(1)).registerCanvasControl(eq(ClipboardControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(ControlPointControl.class)); verify(managedSession, times(1)).init(eq(metadata), eq(command)); } |
### 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 @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (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 testSaveOrUpdate() { final ServiceCallback<D> callback = mock(ServiceCallback.class); tested.saveOrUpdate(diagram, callback); verify(diagramService, times(1)).saveOrUpdate(eq(diagram)); verify(callback, times(1)).onSuccess(eq(diagram)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); }
@Test @SuppressWarnings("unchecked") public void testSaveSessionDiagramSavedEventFiredWhenSaveWasSuccessful() { when(sessionManager.getCurrentSession()).thenReturn(session); ServiceCallback serviceCallback = mock(ServiceCallback.class); when(diagramService.saveOrUpdate(any())).thenReturn(metadata); tested.saveOrUpdate(diagram, serviceCallback); verify(sessionDiagramSavedEvent).fire(new SessionDiagramSavedEvent(session)); }
@Test @SuppressWarnings("unchecked") public void testSaveSessionDiagramSavedEventNotFiredWhenSaveWasUnSuccessful() { TestUtils.prepareServiceCallerError(diagramService, diagramServiceCaller, new Throwable("some error")); when(sessionManager.getCurrentSession()).thenReturn(session); ServiceCallback serviceCallback = mock(ServiceCallback.class); when(diagramService.saveOrUpdate(any())).thenReturn(metadata); tested.saveOrUpdate(diagram, serviceCallback); verify(sessionDiagramSavedEvent, never()).fire(any(SessionDiagramSavedEvent.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 @SuppressWarnings("unchecked") public void lookup(final DiagramLookupRequest request, final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback) { diagramLookupServiceCaller.call(response -> callback.onSuccess((LookupManager.LookupResponse<DiagramRepresentation>) response), (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).lookup(request); } 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 testLookup() { final DiagramLookupRequest request = mock(DiagramLookupRequest.class); final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback = mock(ServiceCallback.class); tested.lookup(request, callback); verify(diagramLookupService, times(1)).lookup(eq(request)); verify(callback, times(1)).onSuccess(any(LookupManager.LookupResponse.class)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); } |
### Question:
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { protected void updateClientMetadata(final D diagram) { if (null != diagram) { final Metadata metadata = diagram.getMetadata(); if (null != metadata && isEmpty(metadata.getShapeSetId())) { final String sId = shapeManager.getDefaultShapeSet(metadata.getDefinitionSetId()).getId(); metadata.setShapeSetId(sId); } } } 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 testUpdateClientMetadata() { final String ssid = "shapeSet1"; final ShapeSet shapeSet = mock(ShapeSet.class); final ServiceCallback<D> callback = mock(ServiceCallback.class); when(shapeSet.getId()).thenReturn(ssid); when(shapeManager.getDefaultShapeSet(anyString())).thenReturn(shapeSet); when(metadata.getShapeSetId()).thenReturn(null); when(diagramService.getDiagramByPath(eq(path))).thenReturn(diagram); tested.add(diagram, callback); tested.saveOrUpdate(diagram, callback); tested.getByPath(path, callback); verify(metadata, times(3)).setShapeSetId(eq(ssid)); } |
### 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)); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.