method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void clear() { getState().clear(); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }### Answer:
@Test public void testClear() { tested.clear(); verify(state, times(1)).clear(); } |
### Question:
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void addElement(final Element candidate) { updatedElements.add(candidate); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }### Answer:
@Test public void testAddElement() { Element node1 = new NodeImpl<>("parent"); tested.addElement(node1); assertEquals("Should be One Element in Updated Elements", 1, tested.getUpdatedElements().size()); } |
### Question:
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public List<Element> getUpdatedElements() { return updatedElements; } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }### Answer:
@Test public void testGetUpdatedElements() { Element node1 = new NodeImpl<>("parent"); tested.addElement(node1); assertEquals("node 1 should be returned from Updated Elements", node1, tested.getUpdatedElements().get(0)); } |
### Question:
ListSelectorViewImpl implements ListSelectorView { @Override public void show(final Optional<String> title) { getElement().getClassList().add(OPEN); schedule(() -> getElement().focus()); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }### Answer:
@Test public void testShow() { view.show(Optional.empty()); verify(viewElementCSSClasses).add(OPEN); verify(viewElement).focus(); } |
### Question:
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void resetUpdatedElements() { updatedElements.clear(); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }### Answer:
@Test public void testResetUpdatedElements() { Element parent = new NodeImpl<>("parent"); tested.addElement(parent); assertEquals("Should be One Element in Updated Elements", 1, tested.getUpdatedElements().size()); tested.resetUpdatedElements(); assertEquals("Updated Elements should be empty", 0, tested.getUpdatedElements().size()); } |
### Question:
DiagramClientErrorHandler extends ClientErrorHandler { public void handleError(ClientRuntimeError error, Consumer<String> showError) { if (Objects.isNull(error)) { throw new RuntimeException("Error cannot be null"); } String message = null; if (error.getThrowable() instanceof DefinitionNotFoundException) { message = translationService.getValue(CoreTranslationMessages.DIAGRAM_LOAD_FAIL_UNSUPPORTED_ELEMENTS, ((DefinitionNotFoundException) error.getThrowable()).getDefinitionId()); } showError.accept(Objects.nonNull(message) ? message : error.toString()); } @Inject DiagramClientErrorHandler(final ClientTranslationService translationService); void handleError(ClientRuntimeError error, Consumer<String> showError); }### Answer:
@Test public void handleErrorTest() { reset(clientRuntimeError); when(clientRuntimeError.getThrowable()).thenReturn(new DefinitionNotFoundException("Error", DEFINITION_ID)); diagramClientErrorHandler.handleError(clientRuntimeError, message -> Assert.assertEquals(ERROR_MESSAGE, message)); when(clientRuntimeError.getThrowable()).thenReturn(new RuntimeException()); when(clientRuntimeError.toString()).thenReturn("runtime"); diagramClientErrorHandler.handleError(clientRuntimeError, message -> Assert.assertEquals("runtime", message)); } |
### Question:
StunnerPreferencesRegistries { public <T> T get(final String definitionSetId, Class<T> preferenceType) { final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); return get(qualifier, preferenceType); } @Inject StunnerPreferencesRegistries(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistry> preferencesRegistries); T get(final String definitionSetId, Class<T> preferenceType); T get(final Annotation qualifier, Class<T> preferenceType); }### Answer:
@Test @SuppressWarnings("unchecked") public void testGet() { StunnerPreferences instance = tested.get(DEF_SET_ID, StunnerPreferences.class); verify(preferencesRegistries, times(1)).select(eq(qualifier)); assertEquals(preferences, instance); }
@Test @SuppressWarnings("unchecked") public void testGetTextPreferences() { StunnerTextPreferences instance = tested.get(DEF_SET_ID, StunnerTextPreferences.class); verify(preferencesRegistries, times(1)).select(eq(qualifier)); assertEquals(textPreferences, instance); } |
### Question:
StunnerPreferencesRegistryLoader { @PreDestroy public void destroy() { preferencesHolders.destroyAll(); } @Inject StunnerPreferencesRegistryLoader(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistryHolder> preferencesHolders,
final StunnerPreferences preferences,
final StunnerTextPreferences textPreferences); void load(final Metadata metadata,
final ParameterizedCommand<StunnerPreferences> loadCompleteCallback,
final ParameterizedCommand<Throwable> errorCallback); @PreDestroy void destroy(); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(preferencesHolders, times(1)).destroyAll(); } |
### Question:
CanvasFileExport { public void exportToJpg(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); exportImage(canvasHandler, CanvasExport.URLDataType.JPG, fileName); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }### Answer:
@Test public void testExportToJpg() { when(canvasExport.toImageData(eq(canvasHandler), any(CanvasURLExportSettings.class))).thenReturn(JPG_DATA_URI); tested.exportToJpg(canvasHandler, "file1"); final ArgumentCaptor<ImageDataUriContent> contentArgumentCaptor = ArgumentCaptor.forClass(ImageDataUriContent.class); verify(imageFileExport, times(1)).export(contentArgumentCaptor.capture(), eq("file1.jpg")); verify(pdfFileExport, never()).export(any(PdfDocument.class), anyString()); final ImageDataUriContent imageDataUriContent = contentArgumentCaptor.getValue(); assertEquals(JPG_DATA_URI, imageDataUriContent.getUri()); verify(clearSelectionEvent).fire(any(CanvasClearSelectionEvent.class)); } |
### Question:
CanvasFileExport { public void exportToPdf(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); loadFileExportPreferences(prefs -> exportToPdf(canvasHandler, fileName, prefs.getPdfPreferences())); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }### Answer:
@Test public void testExportToPdf() { when(canvasExport.toImageData(eq(canvasHandler), any(CanvasURLExportSettings.class))).thenReturn(JPG_DATA_URI); verify(imageFileExport, never()).export(any(ImageDataUriContent.class), anyString()); tested.exportToPdf(canvasHandler, "file1"); verify(pdfFileExport, times(1)).export(any(PdfDocument.class), eq("file1.pdf")); verify(clearSelectionEvent).fire(any(CanvasClearSelectionEvent.class)); } |
### Question:
ListSelectorViewImpl implements ListSelectorView { @Override public void hide() { getElement().getClassList().remove(OPEN); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }### Answer:
@Test public void testHide() { view.hide(); verify(viewElementCSSClasses).remove(OPEN); } |
### Question:
CanvasFileExport { public void exportToSvg(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); final String fullFileName = fileName + "." + getFileExtension(CanvasExport.URLDataType.SVG); svgFileExport.export(canvasExport.toContext2D(canvasHandler, CanvasExportSettings.build()), fullFileName); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }### Answer:
@Test public void testExportToSVG() { when(canvasExport.toContext2D(eq(canvasHandler), any(CanvasExportSettings.class))).thenReturn(context2D); tested.exportToSvg(canvasHandler, "file1"); verify(svgFileExport, times(1)).export(context2D, "file1.svg"); verify(clearSelectionEvent).fire(any(CanvasClearSelectionEvent.class)); } |
### Question:
CanvasHighlight { public CanvasHighlight unhighLight() { if (!uuids.isEmpty()) { HashSet<String> copy = new HashSet<>(uuids); uuids.clear(); copy.forEach(uuid -> { final Shape shape = getShape(uuid); if (null != shape) { shape.applyState(ShapeState.NONE); } }); } setCursor(AbstractCanvas.Cursors.MOVE); return this; } CanvasHighlight(); CanvasHighlight setCanvasHandler(final AbstractCanvasHandler canvasHandler); CanvasHighlight highLight(final Element<?> node); CanvasHighlight invalid(final Element<?> node); CanvasHighlight invalid(final RuleViolations violations); CanvasHighlight invalid(final Iterable<? extends RuleViolation> violations); CanvasHighlight none(final Element<?> node); CanvasHighlight unhighLight(); void destroy(); }### Answer:
@Test public void testUnhighLight() { tested.highLight(node1); tested.invalid(node2); tested.unhighLight(); verify(shape1, times(1)).applyState(eq(ShapeState.HIGHLIGHT)); verify(shape1, times(1)).applyState(eq(ShapeState.NONE)); verify(shape2, times(1)).applyState(eq(ShapeState.INVALID)); verify(shape2, times(1)).applyState(eq(ShapeState.NONE)); verify(canvasView, atLeastOnce()).setCursor(eq(AbstractCanvas.Cursors.MOVE)); } |
### Question:
CanvasHighlight { public void destroy() { setValidCursor(); this.uuids.clear(); this.canvasHandler = null; } CanvasHighlight(); CanvasHighlight setCanvasHandler(final AbstractCanvasHandler canvasHandler); CanvasHighlight highLight(final Element<?> node); CanvasHighlight invalid(final Element<?> node); CanvasHighlight invalid(final RuleViolations violations); CanvasHighlight invalid(final Iterable<? extends RuleViolation> violations); CanvasHighlight none(final Element<?> node); CanvasHighlight unhighLight(); void destroy(); }### Answer:
@Test public void testDestroy() { tested.highLight(node1); tested.invalid(node2); tested.destroy(); verify(shape1, times(1)).applyState(eq(ShapeState.HIGHLIGHT)); verify(shape1, times(0)).applyState(eq(ShapeState.NONE)); verify(shape2, times(1)).applyState(eq(ShapeState.INVALID)); verify(shape2, times(0)).applyState(eq(ShapeState.NONE)); verify(canvasView, atLeastOnce()).setCursor(eq(AbstractCanvas.Cursors.DEFAULT)); } |
### Question:
ListSelectorViewImpl implements ListSelectorView { void registerOnCloseHandler() { getElement().addEventListener(KEYDOWN, onKeyDown(), false); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }### Answer:
@Test public void testRegisterOnCloseHandler() { final EventListener<Event> onKeyDown = (e) -> {}; doReturn(onKeyDown).when(view).onKeyDown(); view.registerOnCloseHandler(); verify(viewElement).addEventListener(KEYDOWN, onKeyDown, false); } |
### Question:
ListSelectorViewImpl implements ListSelectorView { void returnFocusToPanel() { closedByKeyboardCallback.ifPresent(c -> c.accept(this)); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }### Answer:
@Test public void testReturnFocusToPanel() { view.setOnClosedByKeyboardCallback(canBeClosedByKeyboardConsumer); view.returnFocusToPanel(); verify(canBeClosedByKeyboardConsumer).accept(view); } |
### Question:
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public void register(final Element element) { if (!itemsRegistered().test(element.getUUID()) && element.getContent() instanceof View) { items.put(element.getUUID(), false); } } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); static MapSelectionControl<H> build(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); @Override void clear(); @Override void register(final Element element); @Override void deregister(final Element element); @Override SelectionControl<H, Element> select(final String uuid); @Override SelectionControl<H, Element> deselect(final String uuid); @Override boolean isSelected(final Element element); @Override Collection<String> getSelectedItems(); @Override SelectionControl<H, Element> clearSelection(); @Override Optional<Object> getSelectedItemDefinition(); boolean isReadonly(); void setReadonly(boolean readonly); SelectionControl<H, Element> select(final Collection<String> uuids); SelectionControl<H, Element> deselect(final Collection<String> uuids); boolean isSelected(final String uuid); void onShapeRemoved(final CanvasShapeRemovedEvent shapeRemovedEvent); void onCanvasElementSelected(final CanvasSelectionEvent event); void onCanvasClearSelection(final CanvasClearSelectionEvent event); AbstractCanvasHandler getCanvasHandler(); Predicate<String> itemsRegistered(); AbstractCanvas getCanvas(); }### Answer:
@Test public void testRegisterElement() { tested.init(canvasHandler); assertFalse(isRegistered(element)); tested.register(element); assertTrue(isRegistered(element)); } |
### Question:
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public SelectionControl<H, Element> deselect(final String uuid) { return deselect(Collections.singletonList(uuid)); } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); static MapSelectionControl<H> build(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); @Override void clear(); @Override void register(final Element element); @Override void deregister(final Element element); @Override SelectionControl<H, Element> select(final String uuid); @Override SelectionControl<H, Element> deselect(final String uuid); @Override boolean isSelected(final Element element); @Override Collection<String> getSelectedItems(); @Override SelectionControl<H, Element> clearSelection(); @Override Optional<Object> getSelectedItemDefinition(); boolean isReadonly(); void setReadonly(boolean readonly); SelectionControl<H, Element> select(final Collection<String> uuids); SelectionControl<H, Element> deselect(final Collection<String> uuids); boolean isSelected(final String uuid); void onShapeRemoved(final CanvasShapeRemovedEvent shapeRemovedEvent); void onCanvasElementSelected(final CanvasSelectionEvent event); void onCanvasClearSelection(final CanvasClearSelectionEvent event); AbstractCanvasHandler getCanvasHandler(); Predicate<String> itemsRegistered(); AbstractCanvas getCanvas(); }### Answer:
@Test public void testDeselect() { tested.init(canvasHandler); tested.register(element); tested.select(element.getUUID()); tested.deselect(element.getUUID()); assertTrue(tested.getSelectedItems().isEmpty()); verify(shape, times(1)).applyState(eq(ShapeState.SELECTED)); verify(shape, times(1)).applyState(eq(ShapeState.NONE)); verify(shape, never()).applyState(eq(ShapeState.INVALID)); verify(shape, never()).applyState(eq(ShapeState.HIGHLIGHT)); } |
### Question:
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public SelectionControl<H, Element> clearSelection() { return clearSelection(true); } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); static MapSelectionControl<H> build(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); @Override void clear(); @Override void register(final Element element); @Override void deregister(final Element element); @Override SelectionControl<H, Element> select(final String uuid); @Override SelectionControl<H, Element> deselect(final String uuid); @Override boolean isSelected(final Element element); @Override Collection<String> getSelectedItems(); @Override SelectionControl<H, Element> clearSelection(); @Override Optional<Object> getSelectedItemDefinition(); boolean isReadonly(); void setReadonly(boolean readonly); SelectionControl<H, Element> select(final Collection<String> uuids); SelectionControl<H, Element> deselect(final Collection<String> uuids); boolean isSelected(final String uuid); void onShapeRemoved(final CanvasShapeRemovedEvent shapeRemovedEvent); void onCanvasElementSelected(final CanvasSelectionEvent event); void onCanvasClearSelection(final CanvasClearSelectionEvent event); AbstractCanvasHandler getCanvasHandler(); Predicate<String> itemsRegistered(); AbstractCanvas getCanvas(); }### Answer:
@Test public void testClearSelection() { tested.init(canvasHandler); tested.register(element); tested.select(element.getUUID()); tested.clearSelection(); assertTrue(tested.getSelectedItems().isEmpty()); verify(shape, times(1)).applyState(eq(ShapeState.SELECTED)); verify(shape, times(1)).applyState(eq(ShapeState.NONE)); verify(shape, never()).applyState(eq(ShapeState.INVALID)); verify(shape, never()).applyState(eq(ShapeState.HIGHLIGHT)); verify(clearSelectionEvent, times(1)).fire(any(CanvasClearSelectionEvent.class)); } |
### Question:
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public HTMLElement getElement() { return view.getElement(); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); @Override HTMLElement getElement(); @Override void bind(final B bound,
final int uiRowIndex,
final int uiColumnIndex); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); }### Answer:
@Test public void testGetElement() { final HTMLElement element = mock(HTMLElement.class); when(popover.getElement()).thenReturn(element); final HTMLElement actual = popover.getElement(); assertEquals(element, actual); } |
### Question:
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public void clear() { clearSelection(true); } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); static MapSelectionControl<H> build(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); @Override void clear(); @Override void register(final Element element); @Override void deregister(final Element element); @Override SelectionControl<H, Element> select(final String uuid); @Override SelectionControl<H, Element> deselect(final String uuid); @Override boolean isSelected(final Element element); @Override Collection<String> getSelectedItems(); @Override SelectionControl<H, Element> clearSelection(); @Override Optional<Object> getSelectedItemDefinition(); boolean isReadonly(); void setReadonly(boolean readonly); SelectionControl<H, Element> select(final Collection<String> uuids); SelectionControl<H, Element> deselect(final Collection<String> uuids); boolean isSelected(final String uuid); void onShapeRemoved(final CanvasShapeRemovedEvent shapeRemovedEvent); void onCanvasElementSelected(final CanvasSelectionEvent event); void onCanvasClearSelection(final CanvasClearSelectionEvent event); AbstractCanvasHandler getCanvasHandler(); Predicate<String> itemsRegistered(); AbstractCanvas getCanvas(); }### Answer:
@Test public void testClear() { tested.init(canvasHandler); tested.register(element); tested.select(element.getUUID()); tested.clear(); assertTrue(tested.getSelectedItems().isEmpty()); verify(clearSelectionEvent, times(1)).fire(canvasClearSelectionEventCaptor.capture()); assertEquals(canvasHandler, canvasClearSelectionEventCaptor.getValue().getCanvasHandler()); } |
### Question:
ClipboardControlCleaner { public void onPlaceGainFocusEvent(final @Observes PlaceLostFocusEvent event) { if (verifyIsDiagramEditor(event)) { StreamSupport.stream(clipboardControls.spliterator(), false).forEach(ClipboardControl::clear); } } @Inject ClipboardControlCleaner(final ManagedInstance<ClipboardControl> clipboardControls, final ActivityBeansCache activityBeansCache); void onPlaceGainFocusEvent(final @Observes PlaceLostFocusEvent event); }### Answer:
@Test public void onPlaceGainFocusEvent() { clipboardControlCleaner.onPlaceGainFocusEvent(placeLostFocusEvent); verify(clipboardControl, times(1)).clear(); } |
### Question:
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element) { elements.removeAll(Arrays.stream(element).collect(Collectors.toSet())); return this; } LocalClipboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> set(Element... element); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element); @Override Collection<Element> getElements(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> clear(); @Override boolean hasElements(); @Override String getParent(String uuid); @Override List<Command> getRollbackCommands(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> setRollbackCommand(Command... command); @Override Map<String, EdgeClipboard> getEdgeMap(); @Override EdgeClipboard buildNewEdgeClipboard(final String source, final Connection sourceConnection, final String target, final Connection targetConnection); }### Answer:
@Test public void testRemove() { localClipboardControl.set(graphInstance.startNode); assertTrue(localClipboardControl.hasElements()); localClipboardControl.remove(graphInstance.startNode); assertFalse(localClipboardControl.hasElements()); } |
### Question:
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public ClipboardControl<Element, AbstractCanvas, ClientSession> clear() { commands.clear(); elements.clear(); elementsParent.clear(); return this; } LocalClipboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> set(Element... element); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element); @Override Collection<Element> getElements(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> clear(); @Override boolean hasElements(); @Override String getParent(String uuid); @Override List<Command> getRollbackCommands(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> setRollbackCommand(Command... command); @Override Map<String, EdgeClipboard> getEdgeMap(); @Override EdgeClipboard buildNewEdgeClipboard(final String source, final Connection sourceConnection, final String target, final Connection targetConnection); }### Answer:
@Test public void testClear() { localClipboardControl.set(graphInstance.startNode, graphInstance.intermNode, graphInstance.endNode); assertTrue(localClipboardControl.hasElements()); localClipboardControl.clear(); assertFalse(localClipboardControl.hasElements()); } |
### Question:
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public String getParent(String uuid) { return elementsParent.get(uuid); } LocalClipboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> set(Element... element); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element); @Override Collection<Element> getElements(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> clear(); @Override boolean hasElements(); @Override String getParent(String uuid); @Override List<Command> getRollbackCommands(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> setRollbackCommand(Command... command); @Override Map<String, EdgeClipboard> getEdgeMap(); @Override EdgeClipboard buildNewEdgeClipboard(final String source, final Connection sourceConnection, final String target, final Connection targetConnection); }### Answer:
@Test public void testGetParent() { localClipboardControl.set(graphInstance.startNode); String parentUUID = localClipboardControl.getParent(graphInstance.startNode.getUUID()); assertEquals(parentUUID, graphInstance.parentNode.getUUID()); } |
### Question:
CanvasInlineTextEditorControl extends AbstractCanvasInlineTextEditorControl { @PostConstruct protected void initParameters() { isMultiline = true; borderOffsetX = 2d; borderOffsetY = 2d; underBoxOffset = 2d; topBorderOffset = -2d; fontSizeCorrection = 4d; maxInnerLeftBoxWidth = 190d; maxInnerLeftBoxHeight = 190d; maxInnerTopBoxWidth = 190d; maxInnerTopBoxHeight = 190d; scrollBarOffset = 13d; paletteOffsetX = 0d; innerBoxOffsetY = -1.1d; } @Inject CanvasInlineTextEditorControl(final FloatingView<IsWidget> floatingView,
final @InlineTextEditorBox TextEditorBox<AbstractCanvasHandler, Element> textEditorBox); }### Answer:
@Test public void testInitParameters() { CanvasInlineTextEditorControl tested = mock(CanvasInlineTextEditorControl.class); doCallRealMethod().when(tested).initParameters(); tested.initParameters(); assertTrue(tested.isMultiline); assertEquals(2d, tested.borderOffsetX, 0.001); assertEquals(2d, tested.borderOffsetY, 0.001); assertEquals(2d, tested.underBoxOffset, 0.001); assertEquals(-2d, tested.topBorderOffset, 0.001); assertEquals(4d, tested.fontSizeCorrection, 0.001); assertEquals(190d, tested.maxInnerLeftBoxWidth, 0.001); assertEquals(190d, tested.maxInnerLeftBoxHeight, 0.001); assertEquals(13d, tested.scrollBarOffset, 0.001); assertEquals(0d, tested.paletteOffsetX, 0.001); assertEquals(190d, tested.maxInnerTopBoxWidth, 0.001); assertEquals(190d, tested.maxInnerTopBoxHeight, 0.001); assertEquals(-1.1d, tested.innerBoxOffsetY, 0.001); } |
### Question:
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void bind(final EditorSession session) { keyboardControl = session.getKeyboardControl(); keyboardControl.addKeyShortcutCallback(new KogitoKeyPress(new Key[]{ESC}, "Edit | Hide", this::hide)); keyboardControl.addKeyShortcutCallback(this::onKeyDownEvent); } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); static final double SHAPE_EDIT_ALPHA; static final double TITLE_EDIT_ALPHA; static final double NOT_EDIT_ALPHA; static final String ALIGN_MIDDLE; static final String ALIGN_LEFT; static final String ALIGN_TOP; static final String POSITION_INSIDE; static final String POSITION_OUTSIDE; static final String ORIENTATION_VERTICAL; static final String ORIENTATION_HORIZONTAL; static final double DEFAULT_MARGIN_X; static final double DEFAULT_FONT_SIZE; static final String DEFAULT_FONT_FAMILY; }### Answer:
@Test public void testBind() { control.bind(session); verify(keyboardControl, times(2)) .addKeyShortcutCallback(any(KeyboardControl.KeyShortcutCallback.class)); } |
### Question:
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback) { binding.ifPresent(b -> view.setOnClosedByKeyboardCallback(callback)); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); @Override HTMLElement getElement(); @Override void bind(final B bound,
final int uiRowIndex,
final int uiColumnIndex); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testSetOnClosedByKeyboardCallbackNullControl() { popover.setOnClosedByKeyboardCallback(callback); verify(view, never()).setOnClosedByKeyboardCallback(any(Consumer.class)); } |
### Question:
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider) { getTextEditorBox().setCommandManagerProvider(provider); } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); static final double SHAPE_EDIT_ALPHA; static final double TITLE_EDIT_ALPHA; static final double NOT_EDIT_ALPHA; static final String ALIGN_MIDDLE; static final String ALIGN_LEFT; static final String ALIGN_TOP; static final String POSITION_INSIDE; static final String POSITION_OUTSIDE; static final String ORIENTATION_VERTICAL; static final String ORIENTATION_HORIZONTAL; static final double DEFAULT_MARGIN_X; static final double DEFAULT_FONT_SIZE; static final String DEFAULT_FONT_FAMILY; }### Answer:
@Test public void testSetCommandManagerProvider() { control.setCommandManagerProvider(commandManagerProvider); verify(textEditorBox).setCommandManagerProvider(eq(commandManagerProvider)); } |
### Question:
DefaultToolboxControl extends AbstractToolboxControl { @Override protected List<ActionsToolboxFactory> getFactories() { return Arrays.asList(flowActionsToolboxFactories.get(), morphActionsToolboxFactories.get(), commonActionsToolboxFactories.get()); } @Inject DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories); DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories,
final ToolboxControlImpl<ActionsToolboxFactory> toolboxControl); @PreDestroy @Override void destroy(); }### Answer:
@Test public void testGetTheRightFactories() { final List<ActionsToolboxFactory> factories = this.tested.getFactories(); assertEquals(3, factories.size()); assertTrue(factories.contains(flowActionsToolboxFactoryInstance)); assertTrue(factories.contains(morphActionsToolboxFactoryInstance)); assertTrue(factories.contains(commonActionsToolboxFactoryInstance)); } |
### Question:
DefaultToolboxControl extends AbstractToolboxControl { @PreDestroy @Override public void destroy() { super.destroy(); flowActionsToolboxFactories.destroyAll(); morphActionsToolboxFactories.destroyAll(); commonActionsToolboxFactories.destroyAll(); } @Inject DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories); DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories,
final ToolboxControlImpl<ActionsToolboxFactory> toolboxControl); @PreDestroy @Override void destroy(); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(flowActionsToolboxFactory, times(1)).destroyAll(); verify(morphActionsToolboxFactory, times(1)).destroyAll(); verify(commonActionsToolboxFactory, times(1)).destroyAll(); } |
### Question:
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { public AbstractCanvasHandler getCanvasHandler() { return canvasHandler; } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override Iterator<Toolbox<?>> getToolboxes(final Element element); void destroyToolboxes(); void hideAndDestroyToolboxes(); @SuppressWarnings("unchecked") ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid); ToolboxControl<AbstractCanvasHandler, Element> show(final Element element); AbstractCanvasHandler getCanvasHandler(); boolean isActive(final String uuid); static final Predicate<String> ALWAYS_SHOW_PREDICATE; }### Answer:
@Test public void testInitnable() { tested.init(canvasHandler); assertEquals(canvasHandler, tested.getCanvasHandler()); } |
### Question:
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @SuppressWarnings("unchecked") public ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid) { if (showToolboxPredicate.test(uuid)) { final Node node = canvasHandler.getGraphIndex().getNode(uuid); if (null != node) { return show(node); } } return this; } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override Iterator<Toolbox<?>> getToolboxes(final Element element); void destroyToolboxes(); void hideAndDestroyToolboxes(); @SuppressWarnings("unchecked") ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid); ToolboxControl<AbstractCanvasHandler, Element> show(final Element element); AbstractCanvasHandler getCanvasHandler(); boolean isActive(final String uuid); static final Predicate<String> ALWAYS_SHOW_PREDICATE; }### Answer:
@Test public void testShow() { tested.init(canvasHandler); tested.register(element); assertTrue(tested.isRegistered(element)); tested.show(element); verify(toolbox, times(1)).show(); verify(toolbox, never()).hide(); verify(toolbox, never()).destroy(); } |
### Question:
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void show() { binding.ifPresent(b -> view.show(Optional.ofNullable(getPopoverTitle()))); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); @Override HTMLElement getElement(); @Override void bind(final B bound,
final int uiRowIndex,
final int uiColumnIndex); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testShowNullControl() { popover.show(); verify(view, never()).show(any(Optional.class)); } |
### Question:
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public int getPriority() { return TextPropertyProviderFactory.CATCH_ALL_PRIORITY; } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override String getText(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); }### Answer:
@Test public void checkPriorityEnsuresCatchAllOperation() { assertEquals(TextPropertyProviderFactory.CATCH_ALL_PRIORITY, provider.getPriority()); } |
### Question:
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public boolean supports(final Element<? extends Definition> element) { return true; } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override String getText(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); }### Answer:
@Test @SuppressWarnings("unchecked") public void checkSupportsAllElements() { assertTrue(provider.supports(element)); } |
### Question:
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public String getText(final Element<? extends Definition> element) { return definitionUtils.getName(element.getContent().getDefinition()); } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override String getText(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); }### Answer:
@Test public void checkReadGetsNameFromPropertyMetaData() { provider.getText(element); verify(definitionUtils).getName(eq(definition)); } |
### Question:
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public void setText(final AbstractCanvasHandler canvasHandler, final CanvasCommandManager<AbstractCanvasHandler> commandManager, final Element<? extends Definition> element, final String text) { final Object def = element.getContent().getDefinition(); final String nameField = definitionUtils.getNameIdentifier(def); if (null != nameField) { final CanvasCommand<AbstractCanvasHandler> command = canvasCommandFactory.updatePropertyValue(element, nameField, text); commandManager.execute(canvasHandler, command); } } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override String getText(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); }### Answer:
@Test public void checkWriteUsesCommandToUpdateNamePropertyMetaData() { provider.setText(canvasHandler, commandManager, element, "text"); verify(canvasCommandFactory).updatePropertyValue(eq(element), eq("name"), eq("text")); verify(commandManager).execute(eq(canvasHandler), eq(command)); } |
### Question:
KeysMatcher { public static boolean doKeysMatch(final KeyboardEvent.Key[] actualKeys, final KeyboardEvent.Key... expectedKeys) { if (actualKeys == null) { return expectedKeys == null; } else if (expectedKeys == null) { return false; } if (actualKeys.length != expectedKeys.length) { return false; } final Set<KeyboardEvent.Key> matches = new HashSet<>(); matches.addAll(Arrays.asList(actualKeys)); matches.retainAll(Arrays.asList(expectedKeys)); return matches.size() == expectedKeys.length; } static boolean doKeysMatch(final KeyboardEvent.Key[] actualKeys,
final KeyboardEvent.Key... expectedKeys); static boolean isKeyMatch(final KeyboardEvent.Key[] actualKeys,
final KeyboardEvent.Key... expectedKey); }### Answer:
@Test public void checkMatch() { final boolean match = KeysMatcher.doKeysMatch(keysActual.keys, keysExpected.keys); assertEquals(matches, match); } |
### Question:
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void bind(final EditorSession session) { this.editorSession = session; session.getKeyboardControl().addKeyShortcutCallback(this); } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); @Override void register(Element element); @Override void bind(final EditorSession session); @Override void onKeyShortcut(final KeyboardEvent.Key... keys); String selectedNodeId(); Element selectedNodeElement(); }### Answer:
@Test public void testBind() { assertThat(canvasShortcutsControl.editorSession).isNull(); final EditorSession session = mock(EditorSession.class); final KeyboardControl keyboardControl = mock(KeyboardControl.class); doReturn(keyboardControl).when(session).getKeyboardControl(); canvasShortcutsControl.bind(session); assertThat(canvasShortcutsControl.editorSession).isEqualTo(session); verify(keyboardControl).addKeyShortcutCallback(eq(canvasShortcutsControl)); } |
### Question:
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void hide() { binding.ifPresent(b -> view.hide()); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); @Override HTMLElement getElement(); @Override void bind(final B bound,
final int uiRowIndex,
final int uiColumnIndex); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); }### Answer:
@Test public void testHideNullControl() { popover.hide(); verify(view, never()).hide(); } |
### Question:
KeyboardControlImpl extends AbstractCanvasControl<AbstractCanvas> implements KeyboardControl<AbstractCanvas, ClientSession> { public void setKeyEventHandlerEnabled(final boolean enabled) { this.keyEventHandler.setEnabled(enabled); } @Inject KeyboardControlImpl(final SessionManager clientSessionManager,
final KeyEventHandler keyEventHandler); @Override KeyboardControl<AbstractCanvas, ClientSession> addKeyShortcutCallback(final KeyShortcutCallback shortcutCallback); void setKeyEventHandlerEnabled(final boolean enabled); @Override void bind(final ClientSession session); }### Answer:
@Test public void testSetKeyEventHandlerEnabled() { tested.setKeyEventHandlerEnabled(true); verify(keyEventHandler, times(1)).setEnabled(eq(true)); } |
### Question:
KeyEventHandlerImpl implements KeyEventHandler { private void onKeyUp(final KeyboardEvent.Key key) { if (!enabled) { return; } keys.remove(key); shortcutCallbacks.stream().forEach(s -> s.onKeyUp(key)); } @Override KeyEventHandler addKeyShortcutCallback(final KeyboardControl.KeyShortcutCallback shortcutCallback); @Override KeyEventHandler setTimerDelay(final int millis); @Override @PreDestroy void clear(); @Override void setEnabled(final boolean enabled); void onKeyUpEvent(final @Observes KeyUpEvent event); }### Answer:
@Test public void testOnKeyUp() { tested.onKeyUpEvent(new KeyUpEvent(KeyboardEvent.Key.ALT)); verify(shortcutCallback, times(1)).onKeyUp(eq(KeyboardEvent.Key.ALT)); } |
### Question:
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testInvalidCPIndexDuringExecute() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 4); tested.execute(canvasHandler); }
@Test(expected = IllegalArgumentException.class) public void testInvalidCPDuringExecute() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 2); newControlPoint.setLocation(null); tested.execute(canvasHandler); }
@Test public void execute() { checkExecution(true); } |
### Question:
AbstractPopoverViewImpl implements PopoverView { PopoverOptions createOptions() { final PopoverOptions options = createPopoverOptionsInstance(); options.setContent((element) -> popoverContentElement); options.setAnimation(false); options.setHtml(true); options.setPlacement(PLACEMENT); return options; } protected AbstractPopoverViewImpl(); AbstractPopoverViewImpl(final Div popoverElement,
final Div popoverContentElement,
final JQueryProducer.JQuery<Popover> jQueryPopover); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(final Optional<String> popoverTitle); @Override void hide(); boolean isVisible(); void keyDownEventListener(final Object event); boolean isEscapeKeyPressed(final KeyboardEvent event); boolean isEnterKeyPressed(final KeyboardEvent event); void onClosedByKeyboard(); Optional<Consumer<CanBeClosedByKeyboard>> getClosedByKeyboardCallback(); }### Answer:
@Test public void testCreateOptions() { final PopoverOptions options = mock(PopoverOptions.class); doReturn(options).when(view).createPopoverOptionsInstance(); view.createOptions(); verify(options).setAnimation(false); verify(options).setHtml(true); verify(options).setPlacement(AbstractPopoverViewImpl.PLACEMENT); } |
### Question:
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new UpdateDomainObjectPropertyValueCommand(domainObject, propertyId, value); } UpdateDomainObjectPropertyCommand(final DomainObject domainObject,
final String propertyId,
final Object value); @Override String toString(); }### Answer:
@Test public void testNewGraphCommand() { final Command<GraphCommandExecutionContext, RuleViolation> command = new UpdateDomainObjectPropertyCommand(domainObject, PROPERTY_ID, VALUE).newGraphCommand(canvasHandler); assertThat(command).isInstanceOf(UpdateDomainObjectPropertyValueCommand.class); } |
### Question:
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new RefreshPropertiesPanelCommand(); } UpdateDomainObjectPropertyCommand(final DomainObject domainObject,
final String propertyId,
final Object value); @Override String toString(); }### Answer:
@Test public void testNewCanvasCommandExecute() { final CanvasCommand<AbstractCanvasHandler> command = new UpdateDomainObjectPropertyCommand(domainObject, PROPERTY_ID, VALUE).newCanvasCommand(canvasHandler); assertThat(command).isInstanceOf(UpdateDomainObjectPropertyCommand.RefreshPropertiesPanelCommand.class); assertThat(command.execute(canvasHandler)).isEqualTo(CanvasCommandResultBuilder.SUCCESS); verify(canvasHandler).notifyCanvasDomainObjectUpdated(eq(domainObject)); }
@Test public void testNewCanvasCommandUndo() { final CanvasCommand<AbstractCanvasHandler> command = new UpdateDomainObjectPropertyCommand(domainObject, PROPERTY_ID, VALUE).newCanvasCommand(canvasHandler); assertThat(command).isInstanceOf(UpdateDomainObjectPropertyCommand.RefreshPropertiesPanelCommand.class); assertThat(command.undo(canvasHandler)).isEqualTo(CanvasCommandResultBuilder.SUCCESS); verify(canvasHandler).notifyCanvasDomainObjectUpdated(eq(domainObject)); } |
### Question:
AddCanvasConnectorCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.register(shapeSetId, candidate); if (candidate.getContent() instanceof ViewConnector) { final HasManageableControlPoints<?> view = (HasManageableControlPoints<?>) ShapeUtils.getConnectorShape(candidate, context).getShapeView(); final ControlPoint[] controlPoints = ((ViewConnector) candidate.getContent()).getControlPoints(); if (null != controlPoints) { for (int i = 0; i < controlPoints.length; i++) { view.addControlPoint(controlPoints[i], i); } } } applyConnections(candidate, context, MutationContext.STATIC); context.applyElementMutation(candidate, MutationContext.STATIC); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } return buildResult(); } AddCanvasConnectorCommand(final Edge candidate,
final String shapeSetId); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge getCandidate(); String getShapeSetId(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).register(eq(SHAPE_SET_ID), eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(candidate), any(MutationContext.class)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(source)); verify(candidateShape, times(1)).applyConnections(eq(candidate), eq(sourceShapeView), any(ShapeView.class), any(MutationContext.class)); } |
### Question:
DeleteConnectorCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.DeleteConnectorCommand(candidate); } DeleteConnectorCommand(final Edge candidate); @Override String toString(); }### Answer:
@Test public void testGetGraphCommand() { final org.kie.workbench.common.stunner.core.graph.command.impl.DeleteConnectorCommand graphCommand = (org.kie.workbench.common.stunner.core.graph.command.impl.DeleteConnectorCommand) tested.newGraphCommand(canvasHandler); assertNotNull(graphCommand); assertEquals(candidate, graphCommand.getEdge()); } |
### Question:
DeleteConnectorCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new DeleteCanvasConnectorCommand(candidate); } DeleteConnectorCommand(final Edge candidate); @Override String toString(); }### Answer:
@Test public void testGetCanvasCommand() { final DeleteCanvasConnectorCommand canvasCommand = (DeleteCanvasConnectorCommand) tested.newCanvasCommand(canvasHandler); assertNotNull(canvasCommand); assertEquals(candidate, canvasCommand.getCandidate()); } |
### Question:
UpdateCanvasElementPropertyCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.updateElementProperties(element, MutationContext.STATIC); return buildResult(); } UpdateCanvasElementPropertyCommand(final Element element); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).updateElementProperties(eq(candidate), any(MutationContext.class)); } |
### Question:
AbstractPopoverViewImpl implements PopoverView { public void onClosedByKeyboard() { getClosedByKeyboardCallback().ifPresent(c -> c.accept(this)); } protected AbstractPopoverViewImpl(); AbstractPopoverViewImpl(final Div popoverElement,
final Div popoverContentElement,
final JQueryProducer.JQuery<Popover> jQueryPopover); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(final Optional<String> popoverTitle); @Override void hide(); boolean isVisible(); void keyDownEventListener(final Object event); boolean isEscapeKeyPressed(final KeyboardEvent event); boolean isEnterKeyPressed(final KeyboardEvent event); void onClosedByKeyboard(); Optional<Consumer<CanBeClosedByKeyboard>> getClosedByKeyboardCallback(); }### Answer:
@Test public void testOnClosedByKeyboard() { final Consumer consumer = mock(Consumer.class); final Optional opt = Optional.of(consumer); doReturn(opt).when(view).getClosedByKeyboardCallback(); view.onClosedByKeyboard(); verify(consumer).accept(view); } |
### Question:
AddCanvasChildNodeCommand extends AbstractRegistrationCanvasNodeCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = super.execute(context); context.applyElementMutation(parent, MutationContext.STATIC); return result; } AddCanvasChildNodeCommand(final Node parent,
final Node candidate,
final String shapeSetId); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).register(eq(SHAPE_SET_ID), eq(candidate)); verify(canvasHandler, times(1)).addChild(eq(parent), eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(candidate), any(MutationContext.class)); verify(canvasHandler, times(1)).applyElementMutation(eq(parent), any(MutationContext.class)); } |
### Question:
ClearCanvasCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.clearCanvas(); return buildResult(); } @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }### Answer:
@Test public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).clearCanvas(); } |
### Question:
ClearCanvasCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { throw new UnsupportedOperationException("Undo operation for Clear Canvas Command is still not supported."); } @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testUndo() { tested.undo(canvasHandler); } |
### Question:
DeleteNodeCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new SafeDeleteNodeCommand(candidate, deleteProcessor, options); } DeleteNodeCommand(final Node candidate); DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options); @SuppressWarnings("unchecked") DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options,
final CanvasDeleteProcessor deleteProcessor); Node getCandidate(); SafeDeleteNodeCommand.Options getOptions(); @Override String toString(); CanvasDeleteProcessor getDeleteProcessor(); }### Answer:
@Test public void startNodeTestGraphCommand() { this.tested = new DeleteNodeCommand(graphHolder.startNode); final org.kie.workbench.common.stunner.core.graph.command.impl.SafeDeleteNodeCommand graphCommand = (org.kie.workbench.common.stunner.core.graph.command.impl.SafeDeleteNodeCommand) tested.newGraphCommand(canvasHandler); assertNotNull(graphCommand); assertEquals(graphHolder.startNode, graphCommand.getNode()); }
@Test public void intermediateNodeTestGraphCommand() { this.tested = new DeleteNodeCommand(graphHolder.intermNode); final org.kie.workbench.common.stunner.core.graph.command.impl.SafeDeleteNodeCommand graphCommand = (org.kie.workbench.common.stunner.core.graph.command.impl.SafeDeleteNodeCommand) tested.newGraphCommand(canvasHandler); assertNotNull(graphCommand); assertEquals(graphHolder.intermNode, graphCommand.getNode()); } |
### Question:
CloneConnectorCommand extends AbstractCanvasGraphCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.CloneConnectorCommand(candidate, sourceUUID, targetUUID, getCloneCallback()); } CloneConnectorCommand(final Edge candidate,
final String sourceUUID,
final String targetUUID,
final String shapeSetId,
final Consumer<Edge> callback); @Override String toString(); }### Answer:
@Test public void newGraphCommand() { Command<GraphCommandExecutionContext, RuleViolation> command = cloneConnectorCommand.newGraphCommand(context); assertTrue(command instanceof org.kie.workbench.common.stunner.core.graph.command.impl.CloneConnectorCommand); } |
### Question:
CloneConnectorCommand extends AbstractCanvasGraphCommand { @Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler context) { return command; } CloneConnectorCommand(final Edge candidate,
final String sourceUUID,
final String targetUUID,
final String shapeSetId,
final Consumer<Edge> callback); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void newCanvasCommand() { Command<AbstractCanvasHandler, CanvasViolation> command = cloneConnectorCommand.newCanvasCommand(context); assertTrue(command instanceof CompositeCommand); Consumer<Edge> cloneCallback = cloneConnectorCommand.getCloneCallback(); cloneCallback.accept(clone); CompositeCommand compositeCommand = (CompositeCommand) command; assertTrue(compositeCommand.getCommands().stream().anyMatch(c -> c instanceof AddCanvasConnectorCommand)); assertEquals(((AddCanvasConnectorCommand) compositeCommand.getCommands().stream() .filter(c -> c instanceof AddCanvasConnectorCommand) .findFirst() .get()).getCandidate(), clone); assertTrue(compositeCommand.getCommands().stream().anyMatch(c -> c instanceof SetCanvasConnectionCommand)); assertEquals(((SetCanvasConnectionCommand) compositeCommand.getCommands().stream() .filter(c -> c instanceof SetCanvasConnectionCommand) .findFirst() .get()).getEdge(), clone); } |
### Question:
AbstractPopoverViewImpl implements PopoverView { @Override public void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback) { closedByKeyboardCallback = Optional.ofNullable(callback); } protected AbstractPopoverViewImpl(); AbstractPopoverViewImpl(final Div popoverElement,
final Div popoverContentElement,
final JQueryProducer.JQuery<Popover> jQueryPopover); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(final Optional<String> popoverTitle); @Override void hide(); boolean isVisible(); void keyDownEventListener(final Object event); boolean isEscapeKeyPressed(final KeyboardEvent event); boolean isEnterKeyPressed(final KeyboardEvent event); void onClosedByKeyboard(); Optional<Consumer<CanBeClosedByKeyboard>> getClosedByKeyboardCallback(); }### Answer:
@Test public void testSetOnClosedByKeyboardCallback() { final Consumer consumer = mock(Consumer.class); view.setOnClosedByKeyboardCallback(consumer); final Optional<Consumer<CanBeClosedByKeyboard>> actual = view.getClosedByKeyboardCallback(); assertTrue(actual.isPresent()); assertEquals(consumer, actual.get()); } |
### Question:
UpdateCanvasElementPositionCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> allowResult = allow(context); if (isError(allowResult)) { return allowResult; } context.updateElementPosition(element, MutationContext.STATIC); moveConnectorsToTop(context); return allowResult; } UpdateCanvasElementPositionCommand(final Element<? extends View<?>> element,
final Point2D location); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Element<? extends View<?>> getElement(); Point2D getLocation(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecuteSuccess() { tested = new UpdateCanvasElementPositionCommand(candidate, Point2D.create(0d, 0d)); CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).updateElementPosition(eq(candidate), any(MutationContext.class)); } |
### Question:
AddCanvasDockedNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.register(ssid, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); context.applyElementMutation(parent, MutationContext.STATIC); if (!context.dock(parent, candidate)) { return new CanvasCommandResultBuilder() .addViolation(CanvasViolationImpl.Builder .build(new DockingRuleViolation(parent.getUUID(), candidate.getUUID()))) .build(); } return buildResult(); } AddCanvasDockedNodeCommand(final Node parent,
final Node candidate,
final String ssid); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).register(eq(SHAPE_SET_ID), eq(candidate)); verify(canvasHandler, times(1)).dock(eq(parent), eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(candidate), any(MutationContext.class)); verify(canvasHandler, times(1)).applyElementMutation(eq(parent), any(MutationContext.class)); verify(canvasHandler, never()).addChild(eq(parent), eq(candidate)); } |
### Question:
CloneCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(AbstractCanvasHandler context) { return commands.undo(context); } CloneCanvasNodeCommand(Node parent, Node candidate, String shapeSetId, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); AbstractCanvasCommand createAddCanvasChildNodeCommand(Node parent, Node candidate, String shapeSetId); CloneCanvasNodeCommand createCloneCanvasNodeCommand(Node parent, Node candidate, String shapeSetId); @Override CommandResult<CanvasViolation> execute(AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ManagedInstance<ChildrenTraverseProcessor> getChildrenTraverseProcessor(); Node getParent(); Node getCandidate(); String getShapeSetId(); @Override String toString(); }### Answer:
@Test public void testUndo() { testExecute(); cloneCanvasNodeCommand.undo(canvasHandler); verify(canvasHandler, atLeastOnce()).removeChild(parent, candidate); verify(canvasHandler, atLeastOnce()).deregister(candidate); verify(canvasHandler, atLeastOnce()).removeChild(graphInstance.parentNode, graphInstance.startNode); verify(canvasHandler, atLeastOnce()).deregister(graphInstance.startNode); verify(canvasHandler, atLeastOnce()).removeChild(graphInstance.parentNode, graphInstance.intermNode); verify(canvasHandler, atLeastOnce()).deregister(graphInstance.intermNode); verify(canvasHandler, atLeastOnce()).removeChild(graphInstance.parentNode, graphInstance.endNode); verify(canvasHandler, atLeastOnce()).deregister(graphInstance.endNode); verify(canvasHandler, atLeastOnce()).deregister(graphInstance.edge1); verify(canvasHandler, atLeastOnce()).deregister(graphInstance.edge2); } |
### Question:
DeleteCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (null != parent) { context.removeChild(parent, candidate); } context.deregister(candidate); if (null != parent) { context.applyElementMutation(parent, MutationContext.STATIC); } return buildResult(); } DeleteCanvasNodeCommand(final Node candidate); DeleteCanvasNodeCommand(final Node candidate,
final Node parent); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @SuppressWarnings("unchecked") static Node getParent(final Node node); static boolean isChildEdge(final Edge edge); static boolean isDockEdge(final Edge edge); Node getCandidate(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).removeChild(eq(parent), eq(candidate)); verify(canvasHandler, times(1)).deregister(eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(parent), any(MutationContext.class)); } |
### Question:
DeleteCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { final String ssid = context.getDiagram().getMetadata().getShapeSetId(); final AbstractCanvasCommand command = createUndoCommand(parent, candidate, ssid); return command.execute(context); } DeleteCanvasNodeCommand(final Node candidate); DeleteCanvasNodeCommand(final Node candidate,
final Node parent); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @SuppressWarnings("unchecked") static Node getParent(final Node node); static boolean isChildEdge(final Edge edge); static boolean isDockEdge(final Edge edge); Node getCandidate(); @Override String toString(); }### Answer:
@Test public void testUndo() { tested.undo(canvasHandler); verify(canvasHandler).register(SHAPE_SET_ID, candidate); verify(canvasHandler).addChild(parent, candidate); } |
### Question:
CellEditorControlsViewImpl implements CellEditorControlsView { @Override public void show(final PopupEditorControls editor, final int x, final int y) { DOMUtil.removeAllChildren(cellEditorControlsContainer); cellEditorControlsContainer.appendChild(editor.getElement()); final CSSStyleDeclaration style = getElement().getStyle(); style.setProperty(LEFT, x + PX); style.setProperty(TOP, y + PX); setActiveEditor(Optional.of(editor)); setOnClosedByKeyboardCallback(editor); editor.show(); } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); Optional<PopupEditorControls> getActiveEditor(); void setActiveEditor(final Optional<PopupEditorControls> activeEditor); @PostConstruct void setup(); @PreDestroy void destroy(); @Override void show(final PopupEditorControls editor,
final int x,
final int y); @Override void hide(); static final String LEFT; static final String TOP; }### Answer:
@Test public void testShow() { final PopupEditorControls editor = mock(PopupEditorControls.class); final int x = 10; final int y = 20; final HTMLElement element = mock(HTMLElement.class); doReturn(element).when(view).getElement(); final CSSStyleDeclaration style = mock(CSSStyleDeclaration.class); when(element.getStyle()).thenReturn(style); view.show(editor, x, y); verify(style).setProperty(LEFT, x + PX); verify(style).setProperty(TOP, y + PX); verify(view).setOnClosedByKeyboardCallback(editor); verify(editor).show(); } |
### Question:
ClearCommand extends AbstractCanvasGraphCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { final String rootUUID = context.getDiagram().getMetadata().getCanvasRootUUID(); return new ClearGraphCommand(rootUUID); } @Override String toString(); }### Answer:
@Test public void testGetGraphCommand() { final ClearGraphCommand graphCommand = (ClearGraphCommand) tested.newGraphCommand(canvasHandler); assertNotNull(graphCommand); assertEquals(CANVAS_ROOT_UUID, graphCommand.getRootUUID()); } |
### Question:
ClearCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new ClearCanvasCommand(); } @Override String toString(); }### Answer:
@Test public void testGetCanvasCommand() { final ClearCanvasCommand canvasCommand = (ClearCanvasCommand) tested.newCanvasCommand(canvasHandler); assertNotNull(canvasCommand); } |
### Question:
UpdateElementPropertyCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return (element instanceof Node ? new UpdateElementPropertyValueCommand(element, field, value) : new UpdateElementPropertyValueCommand(element.getUUID(), field, value)); } UpdateElementPropertyCommand(final Element element,
final String field,
final Object value); Element getElement(); String getField(); Object getValue(); @Override String toString(); }### Answer:
@Test public void testNewGraphCommand() { Command<GraphCommandExecutionContext, RuleViolation> command; String propertyId = "name"; String value = "updated value"; command = new UpdateElementPropertyCommand(element, propertyId, value).newGraphCommand(abstractCanvasHandler); assertEquals(command.getClass(), UpdateElementPropertyValueCommand.class); command = new UpdateElementPropertyCommand(node, propertyId, value).newGraphCommand(abstractCanvasHandler); assertEquals(command.getClass(), UpdateElementPropertyValueCommand.class); } |
### Question:
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; } @Override Command<GraphCommandExecutionContext, RuleViolation> getGraphCommand(final AbstractCanvasHandler context); Command<AbstractCanvasHandler, CanvasViolation> getCanvasCommand(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); }### Answer:
@Test @SuppressWarnings("unchecked") public void testAllow() { CommandResult<CanvasViolation> result = tested.allow(canvasHandler); verify(graphCommand, times(1)).allow(eq(graphContext)); verify(canvasCommand, times(1)).allow(eq(canvasHandler)); assertEquals(CommandResult.Type.INFO, result.getType()); assertFalse(result.getViolations().iterator().hasNext()); }
@Test @SuppressWarnings("unchecked") public void testCanvasCommandNotAllowed() { when(canvasCommand.allow(eq(canvasHandler))).thenReturn(CANVAS_COMMAND_FAILED); CommandResult<CanvasViolation> result = tested.allow(canvasHandler); verify(graphCommand, times(1)).allow(eq(graphContext)); verify(canvasCommand, times(1)).allow(eq(canvasHandler)); assertEquals(CommandResult.Type.ERROR, result.getType()); }
@Test @SuppressWarnings("unchecked") public void testGraphCommandNotAllowed() { when(graphCommand.allow(eq(graphContext))).thenReturn(GRAPH_COMMAND_FAILED); CommandResult<CanvasViolation> result = tested.allow(canvasHandler); verify(graphCommand, times(1)).allow(eq(graphContext)); verify(canvasCommand, never()).allow(eq(canvasHandler)); assertEquals(CommandResult.Type.ERROR, result.getType()); } |
### Question:
CellEditorControlsViewImpl implements CellEditorControlsView { void setOnClosedByKeyboardCallback(final PopupEditorControls editor) { if (editor instanceof CanBeClosedByKeyboard) { ((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(this::focusOnDMNContainer); } } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); Optional<PopupEditorControls> getActiveEditor(); void setActiveEditor(final Optional<PopupEditorControls> activeEditor); @PostConstruct void setup(); @PreDestroy void destroy(); @Override void show(final PopupEditorControls editor,
final int x,
final int y); @Override void hide(); static final String LEFT; static final String TOP; }### Answer:
@Test public void testSetOnClosedByKeyboardCallback() { final PopupEditorControls editor = mock(PopupEditorControls.class, withSettings().extraInterfaces(CanBeClosedByKeyboard.class)); view.setOnClosedByKeyboardCallback(editor); verify((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(any()); } |
### Question:
DMNContentServiceImpl extends KieService<String> implements DMNContentService { @Override public String getContent(final Path path) { return getSource(path); } @Inject DMNContentServiceImpl(final CommentedOptionFactory commentedOptionFactory,
final DMNIOHelper dmnIOHelper,
final DMNPathsHelper pathsHelper,
final PMMLIncludedDocumentFactory pmmlIncludedDocumentFactory); @Override String getContent(final Path path); @Override DMNContentResource getProjectContent(final Path path,
final String defSetId); @Override void saveContent(final Path path,
final String content,
final Metadata metadata,
final String comment); @Override List<Path> getModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getDMNModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getPMMLModelsPaths(final WorkspaceProject workspaceProject); @Override PMMLDocumentMetadata loadPMMLDocumentMetadata(final Path path); @Override String getSource(final Path path); }### Answer:
@Test public void testGetContent() { final String actual = "<xml/>"; doReturn(actual).when(service).getSource(path); final String expected = service.getContent(path); assertEquals(expected, actual); } |
### Question:
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.EXECUTE); if (canDoNexOperation(result)) { final CommandResult<CanvasViolation> canvasResult = performOperationOnCanvas(context, CommandOperation.EXECUTE); if (!canDoNexOperation(canvasResult)) { performOperationOnGraph(context, CommandOperation.UNDO); return canvasResult; } } return result; } @Override Command<GraphCommandExecutionContext, RuleViolation> getGraphCommand(final AbstractCanvasHandler context); Command<AbstractCanvasHandler, CanvasViolation> getCanvasCommand(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { CommandResult<CanvasViolation> result = tested.execute(canvasHandler); verify(graphCommand, times(1)).execute(eq(graphContext)); verify(canvasCommand, times(1)).execute(eq(canvasHandler)); assertEquals(CommandResult.Type.INFO, result.getType()); assertFalse(result.getViolations().iterator().hasNext()); } |
### Question:
CloneNodeCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.CloneNodeCommand(candidate, parentUuid, getClonePosition(), cloneNodeCallback(context), childrenTraverseProcessor); } @SuppressWarnings("unchecked") CloneNodeCommand(final Node candidate, final String parentUuid, final Point2D cloneLocation, final Consumer<Node> cloneNodeCommandCallback, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); CloneCanvasNodeCommand getCloneCanvasNodeCommand(Node parent, Node clone, String shapeId); ManagedInstance<ChildrenTraverseProcessor> getChildrenTraverseProcessor(); Node getCandidate(); @Override String toString(); }### Answer:
@Test public void testNewGraphCommand() { Command<GraphCommandExecutionContext, RuleViolation> graphCommand = cloneNodeCommand.newGraphCommand(canvasHandler); assertTrue(graphCommand instanceof org.kie.workbench.common.stunner.core.graph.command.impl.CloneNodeCommand); } |
### Question:
CloneNodeCommand extends AbstractCanvasGraphCommand { @Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler context) { return this.command; } @SuppressWarnings("unchecked") CloneNodeCommand(final Node candidate, final String parentUuid, final Point2D cloneLocation, final Consumer<Node> cloneNodeCommandCallback, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); CloneCanvasNodeCommand getCloneCanvasNodeCommand(Node parent, Node clone, String shapeId); ManagedInstance<ChildrenTraverseProcessor> getChildrenTraverseProcessor(); Node getCandidate(); @Override String toString(); }### Answer:
@Test public void testNewCanvasCommand() { Command<AbstractCanvasHandler, CanvasViolation> canvasCommand = cloneNodeCommand.newCanvasCommand(canvasHandler); assertTrue(canvasCommand instanceof CompositeCommand); } |
### Question:
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; } DeleteCanvasControlPointCommand(final Edge candidate,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }### Answer:
@Test public void testChecks() { tested = new DeleteCanvasControlPointCommand(edge, 0); CommandResult<CanvasViolation> result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); tested = new DeleteCanvasControlPointCommand(edge, 1); result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); tested = new DeleteCanvasControlPointCommand(edge, 2); result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); }
@Test(expected = IllegalArgumentException.class) public void testInvalidIndex() { tested = new DeleteCanvasControlPointCommand(edge, -1); tested.allow(canvasHandler); }
@Test(expected = IllegalArgumentException.class) public void testIndexForbidden() { tested = new DeleteCanvasControlPointCommand(edge, 3); tested.allow(canvasHandler); } |
### Question:
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> { this.deletedControlPoint = view.getManageableControlPoints()[index]; view.deleteControlPoint(index); }); return buildResult(); } DeleteCanvasControlPointCommand(final Edge candidate,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testInvalidIndexDuringExecute() { tested = new DeleteCanvasControlPointCommand(edge, -1); tested.execute(canvasHandler); }
@Test(expected = IllegalArgumentException.class) public void testIndexForbiddenDuringExecute() { tested = new DeleteCanvasControlPointCommand(edge, 3); tested.execute(canvasHandler); } |
### Question:
CellEditorControlsViewImpl implements CellEditorControlsView { void removeOnClosedByKeyboardCallback(final PopupEditorControls editor) { if (editor instanceof CanBeClosedByKeyboard) { ((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(null); } } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); Optional<PopupEditorControls> getActiveEditor(); void setActiveEditor(final Optional<PopupEditorControls> activeEditor); @PostConstruct void setup(); @PreDestroy void destroy(); @Override void show(final PopupEditorControls editor,
final int x,
final int y); @Override void hide(); static final String LEFT; static final String TOP; }### Answer:
@Test public void testRemoveOnClosedByKeyboardCallback() { final PopupEditorControls editor = mock(PopupEditorControls.class, withSettings().extraInterfaces(CanBeClosedByKeyboard.class)); view.removeOnClosedByKeyboardCallback(editor); verify((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(null); } |
### Question:
UpdateCanvasControlPointPositionCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkUpdateControlPoint(getControlPoints(edge), controlPoints); return CanvasCommandResultBuilder.SUCCESS; } UpdateCanvasControlPointPositionCommand(final Edge edge,
final ControlPoint[] controlPoints); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }### Answer:
@Test public void testCheck() { tested = new UpdateCanvasControlPointPositionCommand(edge, newControlPoints); CommandResult<CanvasViolation> result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); }
@Test(expected = IllegalArgumentException.class) public void testCannotUpdateCPs() { newControlPoints = new ControlPoint[]{newControlPoint1, newControlPoint2}; tested = new UpdateCanvasControlPointPositionCommand(edge, newControlPoints); tested.allow(canvasHandler); }
@Test(expected = IllegalArgumentException.class) public void testCannotUpdateCPs2() { viewConnector.setControlPoints(new ControlPoint[]{controlPoint1, controlPoint2}); tested = new UpdateCanvasControlPointPositionCommand(edge, newControlPoints); tested.allow(canvasHandler); } |
### Question:
UpdateCanvasControlPointPositionCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, edge, view -> view.updateControlPoints(controlPoints)); return buildResult(); } UpdateCanvasControlPointPositionCommand(final Edge edge,
final ControlPoint[] controlPoints); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testCannotUpdateCPsDuringExecute() { newControlPoints = new ControlPoint[]{newControlPoint1, newControlPoint2}; tested = new UpdateCanvasControlPointPositionCommand(edge, newControlPoints); tested.execute(canvasHandler); }
@Test public void execute() { checkExecution(true); } |
### Question:
RemoveCanvasChildrenCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { children.forEach(child -> { context.removeChild(parent, child); moveViewConnectorsToTop(context, child); }); return buildResult(); } RemoveCanvasChildrenCommand(final Node parent,
final Collection<Node<?, Edge>> children); RemoveCanvasChildrenCommand(final Node parent,
final Node<?, Edge> child); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); Collection<Node<?, Edge>> getChildren(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).removeChild(eq(graph1Instance.startNode), eq(graph1Instance.intermNode)); verify(canvasHandler, never()).applyElementMutation(eq(graph1Instance.startNode), any(MutationContext.class)); verify(canvasHandler, never()).applyElementMutation(eq(graph1Instance.intermNode), any(MutationContext.class)); verify(connectorShapeView1, times(1)).moveToTop(); verify(connectorShapeView1, never()).moveToBottom(); verify(connectorShapeView1, never()).moveUp(); verify(connectorShapeView1, never()).moveDown(); verify(connectorShapeView2, times(1)).moveToTop(); verify(connectorShapeView2, never()).moveToBottom(); verify(connectorShapeView2, never()).moveUp(); verify(connectorShapeView2, never()).moveDown(); } |
### Question:
CellEditorControlsViewImpl implements CellEditorControlsView { void focusOnDMNContainer(final Object o) { final Element element = getDMNContainer(); if (!Objects.isNull(element)) { element.focus(); } } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); Optional<PopupEditorControls> getActiveEditor(); void setActiveEditor(final Optional<PopupEditorControls> activeEditor); @PostConstruct void setup(); @PreDestroy void destroy(); @Override void show(final PopupEditorControls editor,
final int x,
final int y); @Override void hide(); static final String LEFT; static final String TOP; }### Answer:
@Test public void testFocusOnDMNContainer() { final elemental2.dom.Element dmnContainerElement = mock(elemental2.dom.Element.class); doReturn(dmnContainerElement).when(view).getDMNContainer(); view.focusOnDMNContainer(null); verify(dmnContainerElement).focus(); } |
### Question:
TransformImpl implements Transform { @Override public Point2D getTranslate() { return translate; } TransformImpl(final Point2D translate, final Point2D scale); @Override Point2D getTranslate(); @Override Point2D getScale(); @Override Point2D transform(final double x, final double y); @Override Point2D inverse(final double x, final double y); static final TransformImpl NO_TRANSFORM; }### Answer:
@Test public void testGetTranslate() { final Point2D t = tested.getTranslate(); assertEquals(translate, t); } |
### Question:
TransformImpl implements Transform { @Override public Point2D getScale() { return scale; } TransformImpl(final Point2D translate, final Point2D scale); @Override Point2D getTranslate(); @Override Point2D getScale(); @Override Point2D transform(final double x, final double y); @Override Point2D inverse(final double x, final double y); static final TransformImpl NO_TRANSFORM; }### Answer:
@Test public void testGetScale() { final Point2D s = tested.getScale(); assertEquals(scale, s); } |
### Question:
TransformImpl implements Transform { @Override public Point2D transform(final double x, final double y) { return new Point2D((x * scale.getX()) + translate.getX(), (y * scale.getY()) + translate.getY()); } TransformImpl(final Point2D translate, final Point2D scale); @Override Point2D getTranslate(); @Override Point2D getScale(); @Override Point2D transform(final double x, final double y); @Override Point2D inverse(final double x, final double y); static final TransformImpl NO_TRANSFORM; }### Answer:
@Test public void testTransform() { final Point2D t = tested.transform(1, 1); assertEquals(12, t.getX(), 0); assertEquals(25, t.getY(), 0); final Point2D t1 = tested.transform(2, 2); assertEquals(14, t1.getX(), 0); assertEquals(30, t1.getY(), 0); } |
### Question:
ScreenEventPublisher { protected void onPlaceMaximizedEvent(@Observes PlaceMaximizedEvent event) { diagramEditorMaximizedEventEvent.fire(new ScreenMaximizedEvent(verifyEventIdentifier(event))); } @Inject ScreenEventPublisher(Event<ScreenMaximizedEvent> diagramEditorMaximizedEventEvent,
Event<ScreenMinimizedEvent> diagramEditorMinimizedEventEvent,
ActivityBeansCache activityBeansCache); }### Answer:
@Test public void onPlaceMaximizedEventTest() { screenEventPublisher.onPlaceMaximizedEvent(placeMaximizedEvent); verify(diagramEditorMaximizedEventEvent, Mockito.times(1)).fire(new ScreenMaximizedEvent(true)); reset(syncBeanDef); screenEventPublisher.onPlaceMaximizedEvent(placeMaximizedEvent); verify(diagramEditorMaximizedEventEvent, Mockito.times(1)).fire(new ScreenMaximizedEvent(false)); } |
### Question:
ScreenEventPublisher { protected void onPlaceMinimizedEvent(@Observes PlaceMinimizedEvent event) { diagramEditorMinimizedEventEvent.fire(new ScreenMinimizedEvent(verifyEventIdentifier(event))); } @Inject ScreenEventPublisher(Event<ScreenMaximizedEvent> diagramEditorMaximizedEventEvent,
Event<ScreenMinimizedEvent> diagramEditorMinimizedEventEvent,
ActivityBeansCache activityBeansCache); }### Answer:
@Test public void onPlaceMinimizedEventTest() { screenEventPublisher.onPlaceMinimizedEvent(placeMinimizedEvent); verify(diagramEditorMinimizedEventEvent, Mockito.times(1)).fire(new ScreenMinimizedEvent(true)); reset(syncBeanDef); screenEventPublisher.onPlaceMinimizedEvent(placeMinimizedEvent); verify(diagramEditorMinimizedEventEvent, Mockito.times(1)).fire(new ScreenMinimizedEvent(false)); } |
### Question:
BindableShapeSetThumbProvider implements ShapeSetThumbProvider { protected boolean isSameClass(final Class<?> c1, final Class<?> c2) { return Objects.equals(c1, c2); } BindableShapeSetThumbProvider(final DefinitionManager definitionManager); @Override Class<String> getSourceType(); @Override boolean thumbFor(final String definitionSetId); }### Answer:
@Test public void testIsSameClass() { BindableShapeSetThumbProvider provider = new StubProvider(definitionManager); BindableShapeSetThumbProvider sameProvider = new StubProvider(definitionManager2); assertTrue(provider.isSameClass(provider.getClass(), provider.getClass())); assertTrue(provider.isSameClass(provider.getClass(), sameProvider.getClass())); assertTrue(provider.isSameClass(sameProvider.getClass(), provider.getClass())); assertFalse(provider.isSameClass(null, provider.getClass())); assertFalse(provider.isSameClass(provider.getClass(), null)); assertFalse(provider.isSameClass(provider.getClass(), Object.class)); assertFalse(provider.isSameClass(Object.class, provider.getClass())); } |
### Question:
BackendTranslationService extends AbstractTranslationService { @Override public String getValue(String key) { return key; } @Override String getValue(String key); @Override String getValue(String key, Object... args); @Override Optional<String> getElementName(String uuid); }### Answer:
@Test public void testGetValue() { assertEquals("key1", tested.getValue("key1")); }
@Test public void testGetValueWithArgs() { assertEquals("key1[arg1, arg2]", tested.getValue("key1", "arg1", "arg2")); } |
### Question:
BackendTranslationService extends AbstractTranslationService { @Override public Optional<String> getElementName(String uuid) { return Optional.of(uuid); } @Override String getValue(String key); @Override String getValue(String key, Object... args); @Override Optional<String> getElementName(String uuid); }### Answer:
@Test public void testGetElementName() { assertTrue(tested.getElementName("element1").isPresent()); assertEquals("element1", tested.getElementName("element1").get()); } |
### Question:
CellEditorControlsViewImpl implements CellEditorControlsView { @Override public void hide() { getActiveEditor().ifPresent(PopupEditorControls::hide); getActiveEditor().ifPresent(e -> removeOnClosedByKeyboardCallback(e)); setActiveEditor(Optional.empty()); } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); Optional<PopupEditorControls> getActiveEditor(); void setActiveEditor(final Optional<PopupEditorControls> activeEditor); @PostConstruct void setup(); @PreDestroy void destroy(); @Override void show(final PopupEditorControls editor,
final int x,
final int y); @Override void hide(); static final String LEFT; static final String TOP; }### Answer:
@Test public void testHide() { final PopupEditorControls editor = mock(PopupEditorControls.class); final Optional<PopupEditorControls> activeEditor = Optional.of(editor); doReturn(activeEditor).when(view).getActiveEditor(); view.hide(); verify(editor).hide(); verify(view).removeOnClosedByKeyboardCallback(editor); verify(view).setActiveEditor(Optional.empty()); } |
### Question:
URLUtils { public static String buildDataURIFromStream(final String fileName, final InputStream inputStream) throws Exception { final ByteArrayOutputStream os = new ByteArrayOutputStream(); final String contentType = guessContentType(fileName, inputStream); if (null != contentType) { final byte[] chunk = new byte[4096]; int bytesRead; while ((bytesRead = inputStream.read(chunk)) > 0) { os.write(chunk, 0, bytesRead); } os.flush(); inputStream.close(); return "data:" + contentType + ";base64," + Base64.getEncoder().encodeToString(os.toByteArray()); } else { throw new UnsupportedOperationException("Content type is undefined."); } } static byte[] readBytesFromURL(final String uri); static byte[] readBytes(final InputStream is); static String readFromURL(final String uri); static String readFromURL(final URL url); static String buildDataURIFromURL(final String url); static String buildDataURIFromURL(final URL url); static String buildDataURIFromStream(final String fileName,
final InputStream inputStream); static String guessContentType(final String fileName,
final InputStream stream); }### Answer:
@Test public void buildImageDataUriTest() throws Exception { String dataUri = URLUtils.buildDataURIFromStream("email.gif", loadStream(IMAGE_PATH)); assertEquals(IMAGE_DATA_URI, dataUri); } |
### Question:
AbstractVFSDiagramService implements BaseDiagramService<M, D> { @Override public String getRawContent(D diagram) { try { return serialize(diagram)[0]; } catch (java.io.IOException e) { LOG.error("Error while getting raw content for diagram with UUID [" + diagram.getName() + "].", e); throw new RuntimeException(e); } } AbstractVFSDiagramService(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final BackendRegistryFactory registryFactory,
final User identity); Path create(final Path path,
final String name,
final String defSetId,
final Metadata metadata); @Override String getRawContent(D diagram); @SuppressWarnings("unchecked") D getDiagramByPath(final org.uberfire.backend.vfs.Path file); M saveOrUpdate(final D diagram); @Override Path saveOrUpdateSvg(Path diagramPath, String rawDiagramSvg); boolean delete(final D diagram); boolean contains(final D item); Collection<D> getDiagramsByPath(final org.uberfire.java.nio.file.Path root); boolean accepts(final org.uberfire.backend.vfs.Path path); static final String SVG_SUFFIX; }### Answer:
@Test public void testGetRawContent() throws IOException { String result = diagramService.getRawContent(diagram); assertEquals(DIAGRAM_MARSHALLED, result); } |
### Question:
AbstractVFSDiagramService implements BaseDiagramService<M, D> { public boolean contains(final D item) { return null != getDiagramByPath(item.getMetadata().getPath()); } AbstractVFSDiagramService(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Instance<DefinitionSetService> definitionSetServiceInstances,
final BackendRegistryFactory registryFactory,
final User identity); Path create(final Path path,
final String name,
final String defSetId,
final Metadata metadata); @Override String getRawContent(D diagram); @SuppressWarnings("unchecked") D getDiagramByPath(final org.uberfire.backend.vfs.Path file); M saveOrUpdate(final D diagram); @Override Path saveOrUpdateSvg(Path diagramPath, String rawDiagramSvg); boolean delete(final D diagram); boolean contains(final D item); Collection<D> getDiagramsByPath(final org.uberfire.java.nio.file.Path root); boolean accepts(final org.uberfire.backend.vfs.Path path); static final String SVG_SUFFIX; }### Answer:
@Test public void testContains() { Path path = mock(Path.class); when(metadata.getPath()).thenReturn(path); doReturn(diagram).when(diagramService).getDiagramByPath(path); assertTrue(diagramService.contains(diagram)); verify(diagramService, times(1)).getDiagramByPath(path); } |
### Question:
XMLEncoderDiagramMetadataMarshaller implements DiagramMetadataMarshaller<Metadata> { @Override public String marshall(final Metadata metadata) throws IOException { ByteArrayOutputStream os = new ByteArrayOutputStream(); XMLEncoder encoder = new XMLEncoder(os); encoder.writeObject(metadata); encoder.close(); String raw = os.toString(CHARSET); return raw; } @Override Metadata unmarshall(final InputStream input); @Override String marshall(final Metadata metadata); }### Answer:
@Test public void testEncode() throws Exception { MetadataImpl metadata = new MetadataImpl.MetadataImplBuilder("defSet1").build(); metadata.setTitle("title1"); metadata.setCanvasRootUUID("root1"); metadata.setShapeSetId("ss1"); metadata.setThumbData("thumbData1"); metadata.setTitle("title1"); String result = tested.marshall(metadata); assertNotNull(result); assertFalse(result.isEmpty()); assertTrue(result.contains("<java")); assertTrue(result.contains("</java>")); } |
### Question:
XMLEncoderDiagramMetadataMarshaller implements DiagramMetadataMarshaller<Metadata> { @Override public Metadata unmarshall(final InputStream input) throws IOException { try (final XMLDecoder decoder = new XMLDecoder(input)) { return (Metadata) decoder.readObject(); } } @Override Metadata unmarshall(final InputStream input); @Override String marshall(final Metadata metadata); }### Answer:
@Test public void testDecodeTest1() throws Exception { InputStream is = loadStream(TEST1); Metadata metadata = tested.unmarshall(is); assertNotNull(metadata); assertEquals("defSet1", metadata.getDefinitionSetId()); assertEquals("ss1", metadata.getShapeSetId()); assertEquals("thumbData1", metadata.getThumbData()); assertEquals("title1", metadata.getTitle()); assertEquals("root1", metadata.getCanvasRootUUID()); } |
### Question:
BackendRuleManager implements RuleManager { @Override public RuleHandlerRegistry registry() { return ruleManager.registry(); } protected BackendRuleManager(); @Inject BackendRuleManager(final CachedRuleManager ruleManager,
final @Any Instance<RuleEvaluationHandler<? extends Rule, ?>> 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:
CellEditorControlImpl extends AbstractCanvasControl<AbstractCanvas> implements CellEditorControl { @Override public void bind(final DMNSession session) { this.editorControls.setGridPanelSupplier(Optional.of(session::getGridPanel)); } CellEditorControlImpl(); @Inject CellEditorControlImpl(final CellEditorControls editorControls); @Override void bind(final DMNSession session); @Override CellEditorControls getCellEditorControls(); }### Answer:
@Test public void testBind() { control.bind(session); verify(editorControls).setGridPanelSupplier(gridPanelSupplierArgumentCaptor.capture()); final Optional<Supplier<DMNGridPanel>> gridPanelSupplier = gridPanelSupplierArgumentCaptor.getValue(); assertTrue(gridPanelSupplier.isPresent()); assertEquals(gridPanel, gridPanelSupplier.get().get()); } |
### Question:
BackendRuleManager implements RuleManager { @Override public RuleViolations evaluate(final RuleSet ruleSet, final RuleEvaluationContext context) { return ruleManager.evaluate(ruleSet, context); } protected BackendRuleManager(); @Inject BackendRuleManager(final CachedRuleManager ruleManager,
final @Any Instance<RuleEvaluationHandler<? extends Rule, ?>> ruleEvaluationHandlerInstances); @PostConstruct void init(); @Override RuleHandlerRegistry registry(); @Override RuleViolations evaluate(final RuleSet ruleSet,
final RuleEvaluationContext context); }### Answer:
@Test public void testEvaluate() { RuleSet ruleSet = mock(RuleSet.class); RuleEvaluationContext context = mock(RuleEvaluationContext.class); tested.evaluate(ruleSet, context); verify(ruleManager, times(1)).evaluate(eq(ruleSet), eq(context)); } |
### Question:
BackendProfileManager extends AbstractProfileManager { @PreDestroy public void destroy() { profileInstances.forEach(profileInstances::destroy); } @Inject BackendProfileManager(final DefinitionUtils definitionUtils,
final @Any Instance<Profile> profileInstances); @PreDestroy void destroy(); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(profileInstances, times(1)).destroy(eq(profile1)); verify(profileInstances, times(1)).destroy(eq(profile2)); } |
### Question:
BackendProfileManager extends AbstractProfileManager { @Override protected Function<String, Annotation> getQualifier() { return definitionUtils::getQualifier; } @Inject BackendProfileManager(final DefinitionUtils definitionUtils,
final @Any Instance<Profile> profileInstances); @PreDestroy void destroy(); }### Answer:
@Test public void testGetQualifier() { tested.getQualifier().apply("q1"); verify(definitionUtils, times(1)).getQualifier(eq("q1")); tested.getQualifier().apply("q2"); verify(definitionUtils, times(1)).getQualifier(eq("q2")); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.