src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
DMNGridHelper { public void clearSelections() { getGridWidgets().forEach(gridWidget -> highlightHelper(gridWidget).clearSelections()); } @Inject DMNGridHelper(final SessionManager sessionManager); void highlightCell(final int row,
final int column,
final GridWidget gridWidget); void focusGridPanel(); void clearSelections(); void clearCellHighlights(); Set<GridWidget> getGridWidgets(); }
|
@Test public void clearSelections() { when(defaultGridLayer.getGridWidgets()).thenReturn(asSet(gridWidget1, null, gridWidget2, null, gridWidget3)); doReturn(highlightHelper).when(helper).highlightHelper(gridWidget1); doReturn(highlightHelper).when(helper).highlightHelper(gridWidget2); doReturn(highlightHelper).when(helper).highlightHelper(gridWidget3); helper.clearSelections(); verify(highlightHelper, times(3)).clearSelections(); }
|
DMNGridHelper { public Set<GridWidget> getGridWidgets() { return getDefaultGridLayer() .getGridWidgets() .stream() .filter(Objects::nonNull) .collect(Collectors.toSet()); } @Inject DMNGridHelper(final SessionManager sessionManager); void highlightCell(final int row,
final int column,
final GridWidget gridWidget); void focusGridPanel(); void clearSelections(); void clearCellHighlights(); Set<GridWidget> getGridWidgets(); }
|
@Test public void getGridWidgets() { when(defaultGridLayer.getGridWidgets()).thenReturn(asSet(gridWidget1, null, gridWidget2, null, gridWidget3)); final Set<GridWidget> actualGridWidgets = helper.getGridWidgets(); final Set<GridWidget> expectedGridWidgets = asSet(gridWidget1, gridWidget2, gridWidget3); assertEquals(expectedGridWidgets, actualGridWidgets); }
|
DMNGridHelper { public void focusGridPanel() { getGridPanel().setFocus(true); } @Inject DMNGridHelper(final SessionManager sessionManager); void highlightCell(final int row,
final int column,
final GridWidget gridWidget); void focusGridPanel(); void clearSelections(); void clearCellHighlights(); Set<GridWidget> getGridWidgets(); }
|
@Test public void testFocusGridPanel() { helper.focusGridPanel(); verify(gridPanel).setFocus(true); }
|
DMNGridSubIndex implements DMNSubIndex { @Override public List<DMNSearchableElement> getSearchableElements() { return dmnGridHelper .getGridWidgets() .stream() .flatMap(gridWidget -> getSearchableElements(gridWidget).stream()) .collect(Collectors.toList()); } @Inject DMNGridSubIndex(final DMNGridHelper dmnGridHelper); @Override List<DMNSearchableElement> getSearchableElements(); @Override void onSearchClosed(); @Override void onNoResultsFound(); }
|
@Test public void testGetSearchableElements() { final List<DMNSearchableElement> elements = index .getSearchableElements() .stream() .sorted(Comparator.comparing(DMNSearchableElement::getText)) .collect(Collectors.toList()); assertEquals(7, elements.size()); assertEquals(cellStringValue1, elements.get(0).getText()); assertEquals(cellStringValue2, elements.get(1).getText()); assertEquals(cellStringValue3, elements.get(2).getText()); assertEquals(cellStringValue4, elements.get(3).getText()); assertEquals(cellStringValue5, elements.get(4).getText()); assertEquals(cellStringValue6, elements.get(5).getText()); assertEquals(cellStringValue7, elements.get(6).getText()); elements.get(0).onFound().execute(); elements.get(1).onFound().execute(); elements.get(2).onFound().execute(); elements.get(3).onFound().execute(); elements.get(4).onFound().execute(); elements.get(5).onFound().execute(); elements.get(6).onFound().execute(); verify(dmnGridHelper).highlightCell(0, 0, gridWidget1); verify(dmnGridHelper).highlightCell(0, 1, gridWidget1); verify(dmnGridHelper).highlightCell(0, 0, gridWidget2); verify(dmnGridHelper).highlightCell(1, 0, gridWidget2); verify(dmnGridHelper).highlightCell(0, 0, gridWidget3); verify(dmnGridHelper).highlightCell(0, 1, gridWidget3); verify(dmnGridHelper).highlightCell(1, 0, gridWidget3); }
|
DMNGridSubIndex implements DMNSubIndex { String getValue(final GridCell<?> cell) { final GridCellValue<?> cellValue = cell.getValue(); if (cellValue != null) { final Object value = cellValue.getValue(); if (value instanceof HasNameAndDataTypeCell) { final HasNameAndDataTypeCell hasName = (HasNameAndDataTypeCell) value; return hasName.hasData() ? hasName.getName().getValue() : ""; } else if (value instanceof String || value instanceof Integer) { return String.valueOf(value); } } return ""; } @Inject DMNGridSubIndex(final DMNGridHelper dmnGridHelper); @Override List<DMNSearchableElement> getSearchableElements(); @Override void onSearchClosed(); @Override void onNoResultsFound(); }
|
@Test public void testGetValue() { final String expected = cellStringValue1; final String actual = index.getValue(cell1); assertEquals(expected, actual); }
@Test public void testGetValueWithCellThatHasNameAndDataType() { final String expected = cellStringValue8; final String actual = index.getValue(cell8); assertEquals(expected, actual); }
|
DMNGridSubIndex implements DMNSubIndex { @Override public void onNoResultsFound() { dmnGridHelper.clearSelections(); dmnGridHelper.clearCellHighlights(); } @Inject DMNGridSubIndex(final DMNGridHelper dmnGridHelper); @Override List<DMNSearchableElement> getSearchableElements(); @Override void onSearchClosed(); @Override void onNoResultsFound(); }
|
@Test public void testOnNoResultsFound() { index.onNoResultsFound(); verify(dmnGridHelper).clearSelections(); }
|
DMNGridSubIndex implements DMNSubIndex { @Override public void onSearchClosed() { dmnGridHelper.focusGridPanel(); dmnGridHelper.clearCellHighlights(); } @Inject DMNGridSubIndex(final DMNGridHelper dmnGridHelper); @Override List<DMNSearchableElement> getSearchableElements(); @Override void onSearchClosed(); @Override void onNoResultsFound(); }
|
@Test public void testOnSearchClosed() { index.onSearchClosed(); verify(dmnGridHelper).focusGridPanel(); }
|
DMNGraphUtils { public Definitions getDefinitions(final Diagram diagram) { return dmnDiagramUtils.getDefinitions(diagram); } DMNGraphUtils(); @Inject DMNGraphUtils(final SessionManager sessionManager,
final DMNDiagramUtils dmnDiagramUtils,
final DMNDiagramsSession dmnDiagramsSession); Definitions getModelDefinitions(); List<DRGElement> getModelDRGElements(); Definitions getDefinitions(final Diagram diagram); List<DRGElement> getDRGElements(final Diagram diagram); Stream<Node> getNodeStream(final Diagram diagram); Optional<ClientSession> getCurrentSession(); Stream<Node> getNodeStream(); CanvasHandler getCanvasHandler(); }
|
@Test public void testGetDefinitions() { final Definitions expectedDefinitions = mock(Definitions.class); when(dmnDiagramsSession.getDRGDiagram()).thenReturn(diagram); when(dmnDiagramUtils.getDefinitions(diagram)).thenReturn(expectedDefinitions); final Definitions actualDefinitions = utils.getModelDefinitions(); assertNotNull(actualDefinitions); assertEquals(expectedDefinitions, actualDefinitions); }
@Test public void testGetDefinitionsWithDiagram() { final Definitions expectedDefinitions = mock(Definitions.class); final Diagram diagram = mock(Diagram.class); when(dmnDiagramUtils.getDefinitions(diagram)).thenReturn(expectedDefinitions); final Definitions actualDefinitions = utils.getDefinitions(diagram); assertNotNull(actualDefinitions); assertEquals(expectedDefinitions, actualDefinitions); }
|
DMNGraphUtils { public Definitions getModelDefinitions() { return Optional .ofNullable(dmnDiagramsSession.getDRGDiagram()) .map(e -> dmnDiagramUtils.getDefinitions(e)) .orElse(null); } DMNGraphUtils(); @Inject DMNGraphUtils(final SessionManager sessionManager,
final DMNDiagramUtils dmnDiagramUtils,
final DMNDiagramsSession dmnDiagramsSession); Definitions getModelDefinitions(); List<DRGElement> getModelDRGElements(); Definitions getDefinitions(final Diagram diagram); List<DRGElement> getDRGElements(final Diagram diagram); Stream<Node> getNodeStream(final Diagram diagram); Optional<ClientSession> getCurrentSession(); Stream<Node> getNodeStream(); CanvasHandler getCanvasHandler(); }
|
@Test public void testGetDefinitionsWithNoNodes() { assertNull(utils.getModelDefinitions()); }
|
DMNGraphUtils { private Optional<CanvasHandler> getCanvasHandler(final ClientSession session) { return Optional.ofNullable(session.getCanvasHandler()); } DMNGraphUtils(); @Inject DMNGraphUtils(final SessionManager sessionManager,
final DMNDiagramUtils dmnDiagramUtils,
final DMNDiagramsSession dmnDiagramsSession); Definitions getModelDefinitions(); List<DRGElement> getModelDRGElements(); Definitions getDefinitions(final Diagram diagram); List<DRGElement> getDRGElements(final Diagram diagram); Stream<Node> getNodeStream(final Diagram diagram); Optional<ClientSession> getCurrentSession(); Stream<Node> getNodeStream(); CanvasHandler getCanvasHandler(); }
|
@Test public void testGetCanvasHandler() { final CanvasHandler actualCanvasHandler = utils.getCanvasHandler(); assertEquals(canvasHandler, actualCanvasHandler); }
|
DMNGraphUtils { public List<DRGElement> getModelDRGElements() { return Optional .ofNullable(dmnDiagramsSession.getModelDRGElements()) .orElse(new ArrayList<>()); } DMNGraphUtils(); @Inject DMNGraphUtils(final SessionManager sessionManager,
final DMNDiagramUtils dmnDiagramUtils,
final DMNDiagramsSession dmnDiagramsSession); Definitions getModelDefinitions(); List<DRGElement> getModelDRGElements(); Definitions getDefinitions(final Diagram diagram); List<DRGElement> getDRGElements(final Diagram diagram); Stream<Node> getNodeStream(final Diagram diagram); Optional<ClientSession> getCurrentSession(); Stream<Node> getNodeStream(); CanvasHandler getCanvasHandler(); }
|
@Test public void testGetModelDRGElements() { final List<DRGElement> expectedDRGElements = asList(mock(DRGElement.class), mock(DRGElement.class)); when(dmnDiagramsSession.getModelDRGElements()).thenReturn(expectedDRGElements); final List<DRGElement> actualDRGElements = utils.getModelDRGElements(); assertEquals(expectedDRGElements, actualDRGElements); }
|
DMNGraphUtils { public Stream<Node> getNodeStream(final Diagram diagram) { return dmnDiagramUtils.getNodeStream(diagram); } DMNGraphUtils(); @Inject DMNGraphUtils(final SessionManager sessionManager,
final DMNDiagramUtils dmnDiagramUtils,
final DMNDiagramsSession dmnDiagramsSession); Definitions getModelDefinitions(); List<DRGElement> getModelDRGElements(); Definitions getDefinitions(final Diagram diagram); List<DRGElement> getDRGElements(final Diagram diagram); Stream<Node> getNodeStream(final Diagram diagram); Optional<ClientSession> getCurrentSession(); Stream<Node> getNodeStream(); CanvasHandler getCanvasHandler(); }
|
@Test public void testGetNodeStream() { final Stream<Node> expectedStream = Stream.of(mock(Node.class)); when(dmnDiagramsSession.getCurrentGraphDiagram()).thenReturn(diagram); when(dmnDiagramUtils.getNodeStream(diagram)).thenReturn(expectedStream); final Stream<Node> actualStream = utils.getNodeStream(); assertEquals(expectedStream, actualStream); }
|
DMNElementsSynchronizer { public void onExpressionEditorChanged(final @Observes ExpressionEditorChanged event) { final Optional<Node> node = getNode(event.getNodeUUID()); synchronizeFromNode(node); } @Inject DMNElementsSynchronizer(final DMNDiagramsSession dmnDiagramsSession,
final Event<RefreshDecisionComponents> refreshDecisionComponentsEvent,
final DMNGraphUtils graphUtils,
final NodeTextSetter nodeTextSetter); void onExpressionEditorChanged(final @Observes ExpressionEditorChanged event); void onPropertyChanged(final @Observes FormFieldChanged event); void synchronizeElementsFrom(final DRGElement drgElement); void synchronizeFromNode(final Optional<Node> node); }
|
@Test public void testOnExpressionEditorChanged() { final ExpressionEditorChanged event = mock(ExpressionEditorChanged.class); final String id = "id"; final Node node = mock(Node.class); final Optional<Node> nodeOptional = Optional.of(node); when(event.getNodeUUID()).thenReturn(id); doReturn(nodeOptional).when(synchronizer).getNode(id); doNothing().when(synchronizer).synchronizeFromNode(nodeOptional); synchronizer.onExpressionEditorChanged(event); verify(synchronizer).getNode(id); verify(synchronizer).synchronizeFromNode(nodeOptional); }
|
DMNElementsSynchronizer { public void onPropertyChanged(final @Observes FormFieldChanged event) { final Optional<Node> node = getNode(event.getUuid()); synchronizeFromNode(node); } @Inject DMNElementsSynchronizer(final DMNDiagramsSession dmnDiagramsSession,
final Event<RefreshDecisionComponents> refreshDecisionComponentsEvent,
final DMNGraphUtils graphUtils,
final NodeTextSetter nodeTextSetter); void onExpressionEditorChanged(final @Observes ExpressionEditorChanged event); void onPropertyChanged(final @Observes FormFieldChanged event); void synchronizeElementsFrom(final DRGElement drgElement); void synchronizeFromNode(final Optional<Node> node); }
|
@Test public void testOnPropertyChanged() { final FormFieldChanged event = mock(FormFieldChanged.class); final String id = "id"; final Node node = mock(Node.class); final Optional<Node> nodeOptional = Optional.of(node); when(event.getUuid()).thenReturn(id); doReturn(nodeOptional).when(synchronizer).getNode(id); doNothing().when(synchronizer).synchronizeFromNode(nodeOptional); synchronizer.onPropertyChanged(event); verify(synchronizer).getNode(id); verify(synchronizer).synchronizeFromNode(nodeOptional); }
|
DMNElementsSynchronizer { public void synchronizeElementsFrom(final DRGElement drgElement) { final String contentDefinitionId = drgElement.getContentDefinitionId(); final List<Node> nodes = getElementsWithContentId(contentDefinitionId); for (final Node node : nodes) { updateText(drgElement, node); final DRGElement element = getDRGElementFromContentDefinition(node); synchronizeBaseDRGProperties(drgElement, element); synchronizeSpecializedProperties(drgElement, element); } refreshDecisionComponentsEvent.fire(new RefreshDecisionComponents()); } @Inject DMNElementsSynchronizer(final DMNDiagramsSession dmnDiagramsSession,
final Event<RefreshDecisionComponents> refreshDecisionComponentsEvent,
final DMNGraphUtils graphUtils,
final NodeTextSetter nodeTextSetter); void onExpressionEditorChanged(final @Observes ExpressionEditorChanged event); void onPropertyChanged(final @Observes FormFieldChanged event); void synchronizeElementsFrom(final DRGElement drgElement); void synchronizeFromNode(final Optional<Node> node); }
|
@Test public void testSynchronizeElementsFrom() { final Node node1 = mock(Node.class); final Node node2 = mock(Node.class); final Node node3 = mock(Node.class); final List<Node> nodes = Arrays.asList(node1, node2, node3); final DRGElement drgElement = mock(DRGElement.class); final String contentDefinitionId = "id"; final DRGElement drgElement1 = mock(DRGElement.class); final DRGElement drgElement2 = mock(DRGElement.class); final DRGElement drgElement3 = mock(DRGElement.class); when(drgElement.getContentDefinitionId()).thenReturn(contentDefinitionId); doNothing().when(synchronizer).updateText(any(DRGElement.class), any(Node.class)); doReturn(nodes).when(synchronizer).getElementsWithContentId(contentDefinitionId); doReturn(drgElement1).when(synchronizer).getDRGElementFromContentDefinition(node1); doReturn(drgElement2).when(synchronizer).getDRGElementFromContentDefinition(node2); doReturn(drgElement3).when(synchronizer).getDRGElementFromContentDefinition(node3); doNothing().when(synchronizer).synchronizeBaseDRGProperties(any(DRGElement.class), any(DRGElement.class)); doNothing().when(synchronizer).synchronizeSpecializedProperties(any(DRGElement.class), any(DRGElement.class)); synchronizer.synchronizeElementsFrom(drgElement); verify(synchronizer).getElementsWithContentId(contentDefinitionId); verify(synchronizer).updateText(drgElement, node1); verify(synchronizer).updateText(drgElement, node2); verify(synchronizer).updateText(drgElement, node3); verify(synchronizer).synchronizeBaseDRGProperties(drgElement, drgElement1); verify(synchronizer).synchronizeBaseDRGProperties(drgElement, drgElement2); verify(synchronizer).synchronizeBaseDRGProperties(drgElement, drgElement3); verify(synchronizer).synchronizeSpecializedProperties(drgElement, drgElement1); verify(synchronizer).synchronizeSpecializedProperties(drgElement, drgElement2); verify(synchronizer).synchronizeSpecializedProperties(drgElement, drgElement3); verify(refreshDecisionComponentsEvent).fire(any(RefreshDecisionComponents.class)); }
|
DMNElementsSynchronizer { void synchronizeBaseDRGProperties(final DRGElement from, final DRGElement to) { to.setDescription(from.getDescription()); to.setLinksHolder(from.getLinksHolder()); to.setName(from.getName()); } @Inject DMNElementsSynchronizer(final DMNDiagramsSession dmnDiagramsSession,
final Event<RefreshDecisionComponents> refreshDecisionComponentsEvent,
final DMNGraphUtils graphUtils,
final NodeTextSetter nodeTextSetter); void onExpressionEditorChanged(final @Observes ExpressionEditorChanged event); void onPropertyChanged(final @Observes FormFieldChanged event); void synchronizeElementsFrom(final DRGElement drgElement); void synchronizeFromNode(final Optional<Node> node); }
|
@Test public void testSynchronizeBaseDRGProperties() { final DRGElement from = mock(DRGElement.class); final DRGElement to = mock(DRGElement.class); final Description description = mock(Description.class); final DocumentationLinksHolder linksHolder = mock(DocumentationLinksHolder.class); final Name name = mock(Name.class); when(from.getDescription()).thenReturn(description); when(from.getLinksHolder()).thenReturn(linksHolder); when(from.getName()).thenReturn(name); synchronizer.synchronizeBaseDRGProperties(from, to); verify(to).setDescription(description); verify(to).setName(name); verify(to).setLinksHolder(linksHolder); }
|
DMNElementsSynchronizer { void synchronizeKnowledgeSourceNode(final KnowledgeSource from, final KnowledgeSource to) { to.setType(from.getType()); to.setLocationURI(from.getLocationURI()); } @Inject DMNElementsSynchronizer(final DMNDiagramsSession dmnDiagramsSession,
final Event<RefreshDecisionComponents> refreshDecisionComponentsEvent,
final DMNGraphUtils graphUtils,
final NodeTextSetter nodeTextSetter); void onExpressionEditorChanged(final @Observes ExpressionEditorChanged event); void onPropertyChanged(final @Observes FormFieldChanged event); void synchronizeElementsFrom(final DRGElement drgElement); void synchronizeFromNode(final Optional<Node> node); }
|
@Test public void testSynchronizeKnowledgeSourceNode() { final KnowledgeSource from = mock(KnowledgeSource.class); final KnowledgeSource to = mock(KnowledgeSource.class); final KnowledgeSourceType type = mock(KnowledgeSourceType.class); final LocationURI locationURI = mock(LocationURI.class); when(from.getType()).thenReturn(type); when(from.getLocationURI()).thenReturn(locationURI); synchronizer.synchronizeKnowledgeSourceNode(from, to); verify(to).setType(type); verify(to).setLocationURI(locationURI); }
|
DMNElementsSynchronizer { void synchronizeInputDataNode(final InputData from, final InputData to) { to.setVariable(from.getVariable()); } @Inject DMNElementsSynchronizer(final DMNDiagramsSession dmnDiagramsSession,
final Event<RefreshDecisionComponents> refreshDecisionComponentsEvent,
final DMNGraphUtils graphUtils,
final NodeTextSetter nodeTextSetter); void onExpressionEditorChanged(final @Observes ExpressionEditorChanged event); void onPropertyChanged(final @Observes FormFieldChanged event); void synchronizeElementsFrom(final DRGElement drgElement); void synchronizeFromNode(final Optional<Node> node); }
|
@Test public void testSynchronizeInputDataNode() { final InputData from = mock(InputData.class); final InputData to = mock(InputData.class); final InformationItemPrimary variable = mock(InformationItemPrimary.class); when(from.getVariable()).thenReturn(variable); synchronizer.synchronizeInputDataNode(from, to); verify(to).setVariable(variable); }
|
DMNElementsSynchronizer { void synchronizeDecisionServiceNode(final DecisionService from, final DecisionService to) { to.setVariable(from.getVariable()); } @Inject DMNElementsSynchronizer(final DMNDiagramsSession dmnDiagramsSession,
final Event<RefreshDecisionComponents> refreshDecisionComponentsEvent,
final DMNGraphUtils graphUtils,
final NodeTextSetter nodeTextSetter); void onExpressionEditorChanged(final @Observes ExpressionEditorChanged event); void onPropertyChanged(final @Observes FormFieldChanged event); void synchronizeElementsFrom(final DRGElement drgElement); void synchronizeFromNode(final Optional<Node> node); }
|
@Test public void testSynchronizeDecisionServiceNode() { final DecisionService from = mock(DecisionService.class); final DecisionService to = mock(DecisionService.class); final InformationItemPrimary variable = mock(InformationItemPrimary.class); when(from.getVariable()).thenReturn(variable); synchronizer.synchronizeDecisionServiceNode(from, to); verify(to).setVariable(variable); }
|
DMNElementsSynchronizer { void synchronizeBusinessKnowledgeModelNode(final BusinessKnowledgeModel from, final BusinessKnowledgeModel to) { to.setVariable(from.getVariable()); } @Inject DMNElementsSynchronizer(final DMNDiagramsSession dmnDiagramsSession,
final Event<RefreshDecisionComponents> refreshDecisionComponentsEvent,
final DMNGraphUtils graphUtils,
final NodeTextSetter nodeTextSetter); void onExpressionEditorChanged(final @Observes ExpressionEditorChanged event); void onPropertyChanged(final @Observes FormFieldChanged event); void synchronizeElementsFrom(final DRGElement drgElement); void synchronizeFromNode(final Optional<Node> node); }
|
@Test public void testSynchronizeBusinessKnowledgeModelNode() { final BusinessKnowledgeModel from = mock(BusinessKnowledgeModel.class); final BusinessKnowledgeModel to = mock(BusinessKnowledgeModel.class); final InformationItemPrimary variable = mock(InformationItemPrimary.class); when(from.getVariable()).thenReturn(variable); synchronizer.synchronizeBusinessKnowledgeModelNode(from, to); verify(to).setVariable(variable); }
|
DMNElementsSynchronizer { void synchronizeDecisionNode(final Decision from, final Decision to) { to.setQuestion(from.getQuestion()); to.setAllowedAnswers(from.getAllowedAnswers()); to.setExpression(from.getExpression()); to.setVariable(from.getVariable()); } @Inject DMNElementsSynchronizer(final DMNDiagramsSession dmnDiagramsSession,
final Event<RefreshDecisionComponents> refreshDecisionComponentsEvent,
final DMNGraphUtils graphUtils,
final NodeTextSetter nodeTextSetter); void onExpressionEditorChanged(final @Observes ExpressionEditorChanged event); void onPropertyChanged(final @Observes FormFieldChanged event); void synchronizeElementsFrom(final DRGElement drgElement); void synchronizeFromNode(final Optional<Node> node); }
|
@Test public void testSynchronizeDecisionNodeNode() { final Decision from = mock(Decision.class); final Decision to = mock(Decision.class); final Question question = mock(Question.class); final AllowedAnswers allowedAnswers = mock(AllowedAnswers.class); final Expression expression = mock(Expression.class); final InformationItemPrimary variable = mock(InformationItemPrimary.class); when(from.getQuestion()).thenReturn(question); when(from.getAllowedAnswers()).thenReturn(allowedAnswers); when(from.getExpression()).thenReturn(expression); when(from.getVariable()).thenReturn(variable); synchronizer.synchronizeDecisionNode(from, to); verify(to).setQuestion(question); verify(to).setAllowedAnswers(allowedAnswers); verify(to).setExpression(expression); verify(to).setVariable(variable); }
|
DMNElementsSynchronizer { void updateText(final DRGElement from, final Node to) { final String name = from.getName().getValue(); nodeTextSetter.setText(name, to); } @Inject DMNElementsSynchronizer(final DMNDiagramsSession dmnDiagramsSession,
final Event<RefreshDecisionComponents> refreshDecisionComponentsEvent,
final DMNGraphUtils graphUtils,
final NodeTextSetter nodeTextSetter); void onExpressionEditorChanged(final @Observes ExpressionEditorChanged event); void onPropertyChanged(final @Observes FormFieldChanged event); void synchronizeElementsFrom(final DRGElement drgElement); void synchronizeFromNode(final Optional<Node> node); }
|
@Test public void testUpdateText() { final Decision from = mock(Decision.class); final Node to = mock(Node.class); final Name name = mock(Name.class); final String nameValue = "the name"; when(name.getValue()).thenReturn(nameValue); when(from.getName()).thenReturn(name); synchronizer.updateText(from, to); verify(nodeTextSetter).setText(nameValue, to); }
|
DMNElementsSynchronizer { List<Node> getElementsWithContentId(final String contentDefinitionId) { final List<Node> allNodes = dmnDiagramsSession.getAllNodes(); return allNodes .stream() .filter(node -> definitionContainsDRGElement(node) && Objects.equals(getDRGElementFromContentDefinition(node).getContentDefinitionId(), contentDefinitionId)) .collect(Collectors.toList()); } @Inject DMNElementsSynchronizer(final DMNDiagramsSession dmnDiagramsSession,
final Event<RefreshDecisionComponents> refreshDecisionComponentsEvent,
final DMNGraphUtils graphUtils,
final NodeTextSetter nodeTextSetter); void onExpressionEditorChanged(final @Observes ExpressionEditorChanged event); void onPropertyChanged(final @Observes FormFieldChanged event); void synchronizeElementsFrom(final DRGElement drgElement); void synchronizeFromNode(final Optional<Node> node); }
|
@Test public void testGetElementsWithContentId() { final Node node1 = mock(Node.class); final Node node2 = mock(Node.class); final Node node3 = mock(Node.class); final DRGElement contentDefinition1 = mock(DRGElement.class); final DRGElement contentDefinition3 = mock(DRGElement.class); final String theId = "the id"; final String anotherId = "another id"; final List<Node> nodes = Arrays.asList(node1, node2, node3); when(dmnDiagramsSession.getAllNodes()).thenReturn(nodes); when(contentDefinition1.getContentDefinitionId()).thenReturn(theId); when(contentDefinition3.getContentDefinitionId()).thenReturn(anotherId); doReturn(contentDefinition1).when(synchronizer).getDRGElementFromContentDefinition(node1); doReturn(contentDefinition3).when(synchronizer).getDRGElementFromContentDefinition(node3); doReturn(true).when(synchronizer).definitionContainsDRGElement(node1); doReturn(false).when(synchronizer).definitionContainsDRGElement(node2); doReturn(true).when(synchronizer).definitionContainsDRGElement(node3); final List<Node> elements = synchronizer.getElementsWithContentId(theId); verify(synchronizer).definitionContainsDRGElement(node1); verify(synchronizer).definitionContainsDRGElement(node2); verify(synchronizer).definitionContainsDRGElement(node3); verify(synchronizer).getDRGElementFromContentDefinition(node1); verify(synchronizer, never()).getDRGElementFromContentDefinition(node2); verify(synchronizer).getDRGElementFromContentDefinition(node3); assertEquals(1, elements.size()); assertTrue(elements.contains(node1)); }
|
DMNElementsSynchronizer { boolean definitionContainsDRGElement(final Node node) { return node.getContent() instanceof Definition && ((Definition) node.getContent()).getDefinition() instanceof DRGElement; } @Inject DMNElementsSynchronizer(final DMNDiagramsSession dmnDiagramsSession,
final Event<RefreshDecisionComponents> refreshDecisionComponentsEvent,
final DMNGraphUtils graphUtils,
final NodeTextSetter nodeTextSetter); void onExpressionEditorChanged(final @Observes ExpressionEditorChanged event); void onPropertyChanged(final @Observes FormFieldChanged event); void synchronizeElementsFrom(final DRGElement drgElement); void synchronizeFromNode(final Optional<Node> node); }
|
@Test public void testDefinitionContainsDRGElement() { final Node node = mock(Node.class); final Definition definition = mock(Definition.class); final DRGElement drgElement = mock(DRGElement.class); when(definition.getDefinition()).thenReturn(drgElement); when(node.getContent()).thenReturn(definition); final boolean containsDRGElement = synchronizer.definitionContainsDRGElement(node); assertTrue(containsDRGElement); }
@Test public void testDefinitionContainsDRGElement_WhenDoesNotContains() { final Node node = mock(Node.class); final Definition definition = mock(Definition.class); final Object obj = mock(Object.class); when(definition.getDefinition()).thenReturn(obj); when(node.getContent()).thenReturn(definition); final boolean containsDRGElement = synchronizer.definitionContainsDRGElement(node); assertFalse(containsDRGElement); }
@Test public void testDefinitionContainsDRGElement_WhenContentIsNotDefinition() { final Node node = mock(Node.class); final Object obj = mock(Definition.class); when(node.getContent()).thenReturn(obj); final boolean containsDRGElement = synchronizer.definitionContainsDRGElement(node); assertFalse(containsDRGElement); }
|
DMNElementsSynchronizer { DRGElement getDRGElementFromContentDefinition(final Node node) { return ((DRGElement) ((Definition) node.getContent()).getDefinition()); } @Inject DMNElementsSynchronizer(final DMNDiagramsSession dmnDiagramsSession,
final Event<RefreshDecisionComponents> refreshDecisionComponentsEvent,
final DMNGraphUtils graphUtils,
final NodeTextSetter nodeTextSetter); void onExpressionEditorChanged(final @Observes ExpressionEditorChanged event); void onPropertyChanged(final @Observes FormFieldChanged event); void synchronizeElementsFrom(final DRGElement drgElement); void synchronizeFromNode(final Optional<Node> node); }
|
@Test public void testGetDRGElementFromContentDefinition() { final Node node = mock(Node.class); final Definition definition = mock(Definition.class); final DRGElement drgElement = mock(DRGElement.class); when(definition.getDefinition()).thenReturn(drgElement); when(node.getContent()).thenReturn(definition); final DRGElement actual = synchronizer.getDRGElementFromContentDefinition(node); assertEquals(drgElement, actual); }
|
DMNElementsSynchronizer { Optional<Node> getNode(final String nodeUUID) { return graphUtils .getNodeStream() .filter(node -> Objects.equals(node.getUUID(), nodeUUID)) .findFirst(); } @Inject DMNElementsSynchronizer(final DMNDiagramsSession dmnDiagramsSession,
final Event<RefreshDecisionComponents> refreshDecisionComponentsEvent,
final DMNGraphUtils graphUtils,
final NodeTextSetter nodeTextSetter); void onExpressionEditorChanged(final @Observes ExpressionEditorChanged event); void onPropertyChanged(final @Observes FormFieldChanged event); void synchronizeElementsFrom(final DRGElement drgElement); void synchronizeFromNode(final Optional<Node> node); }
|
@Test public void testGetNode() { final Node node1 = mock(Node.class); final Node node2 = mock(Node.class); final Node node3 = mock(Node.class); final String id = "id"; when(node1.getUUID()).thenReturn(id); when(node2.getUUID()).thenReturn("id2"); when(node3.getUUID()).thenReturn("id3"); when(graphUtils.getNodeStream()).thenReturn(Stream.of(node1, node2, node3)); final Optional<Node> node = synchronizer.getNode(id); assertTrue(node.isPresent()); assertEquals(node1, node.get()); }
|
DMNElementsSynchronizer { public void synchronizeFromNode(final Optional<Node> node) { node.ifPresent(n -> { if (n.getContent() instanceof Definition) { final Definition definition = (Definition) n.getContent(); if (definition.getDefinition() instanceof DRGElement) { final DRGElement drgElement = (DRGElement) definition.getDefinition(); synchronizeElementsFrom(drgElement); } } }); } @Inject DMNElementsSynchronizer(final DMNDiagramsSession dmnDiagramsSession,
final Event<RefreshDecisionComponents> refreshDecisionComponentsEvent,
final DMNGraphUtils graphUtils,
final NodeTextSetter nodeTextSetter); void onExpressionEditorChanged(final @Observes ExpressionEditorChanged event); void onPropertyChanged(final @Observes FormFieldChanged event); void synchronizeElementsFrom(final DRGElement drgElement); void synchronizeFromNode(final Optional<Node> node); }
|
@Test public void testSynchronizeFromNode() { final Node node = mock(Node.class); final Optional<Node> optional = Optional.of(node); final Definition definition = mock(Definition.class); final DRGElement drgElement = mock(DRGElement.class); doNothing().when(synchronizer).synchronizeElementsFrom(drgElement); when(definition.getDefinition()).thenReturn(drgElement); when(node.getContent()).thenReturn(definition); synchronizer.synchronizeFromNode(optional); verify(synchronizer).synchronizeElementsFrom(drgElement); }
|
DecisionServiceMoveDividerControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements RequiresCommandManager<AbstractCanvasHandler>,
RequiresCommandManager.CommandManagerProvider<AbstractCanvasHandler> { @Override public CanvasCommandManager<AbstractCanvasHandler> getCommandManager() { return commandManagerProvider.getCommandManager(); } protected DecisionServiceMoveDividerControl(); @Inject DecisionServiceMoveDividerControl(final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override //Override to increase visibility for Unit Tests void registerHandler(final String uuid,
final ViewHandler<?> handler); @Override void setCommandManagerProvider(final RequiresCommandManager.CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasCommandManager<AbstractCanvasHandler> getCommandManager(); }
|
@Test public void testCommandManager() { assertThat(control.getCommandManager()).isEqualTo(commandManager); }
|
DecisionServiceMoveDividerControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements RequiresCommandManager<AbstractCanvasHandler>,
RequiresCommandManager.CommandManagerProvider<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element)) { final Object definition = ((Definition) element.getContent()).getDefinition(); if (!isDecisionServiceDefinition(definition)) { return; } final Canvas<?> canvas = canvasHandler.getCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); final ShapeView<?> shapeView = shape.getShapeView(); if (!isDecisionServiceShapeView(shapeView)) { return; } final DecisionServiceSVGShapeView decisionServiceShapeView = (DecisionServiceSVGShapeView) shapeView; final DragHandler dragHandler = new DragHandler() { @Override public void end(final DragEvent event) { final CommandResult<CanvasViolation> result = doMoveDivider(element, decisionServiceShapeView.getDividerLineY()); if (CommandUtils.isError(result)) { LOGGER.log(Level.WARNING, "Command failed at resize end [result=" + result + "]"); } } }; decisionServiceShapeView.addDividerDragHandler(dragHandler); registerHandler(element.getUUID(), dragHandler); } } protected DecisionServiceMoveDividerControl(); @Inject DecisionServiceMoveDividerControl(final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override //Override to increase visibility for Unit Tests void registerHandler(final String uuid,
final ViewHandler<?> handler); @Override void setCommandManagerProvider(final RequiresCommandManager.CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasCommandManager<AbstractCanvasHandler> getCommandManager(); }
|
@Test @SuppressWarnings("unchecked") public void testRegisterDecisionServiceElementDragEnd() { final DefinitionManager definitionManager = mock(DefinitionManager.class); final AdapterManager adapterManager = mock(AdapterManager.class); final AdapterRegistry adapterRegistry = mock(AdapterRegistry.class); final PropertyAdapter<Object, Object> propertyAdapter = mock(PropertyAdapter.class); final DefinitionAdapter<Object> definitionAdapter = mock(DefinitionAdapter.class); final DecisionServiceDividerLineY dividerLineY = new DecisionServiceDividerLineY(); final Optional dividerYProperty = Optional.of(dividerLineY); final UpdateElementPropertyCommand updateElementPropertyCommand = mock(UpdateElementPropertyCommand.class); final DecisionService decisionService = mock(DecisionService.class); final DecisionServiceSVGShapeView decisionServiceShapeView = mock(DecisionServiceSVGShapeView.class); final DragEvent dragEvent = mock(DragEvent.class); when(canvasHandler.getDefinitionManager()).thenReturn(definitionManager); when(definitionManager.adapters()).thenReturn(adapterManager); when(adapterManager.registry()).thenReturn(adapterRegistry); when(adapterManager.forProperty()).thenReturn(propertyAdapter); when(adapterRegistry.getDefinitionAdapter(any(Class.class))).thenReturn(definitionAdapter); when(definitionAdapter.getProperty(decisionService, DIVIDER_Y_PROPERTY_ID)).thenReturn(dividerYProperty); when(propertyAdapter.getId(dividerLineY)).thenReturn(DIVIDER_Y_PROPERTY_ID); when(canvasCommandFactory.updatePropertyValue(eq(element), eq(DIVIDER_Y_PROPERTY_ID), anyObject())).thenReturn(updateElementPropertyCommand); when(definition.getDefinition()).thenReturn(decisionService); when(shape.getShapeView()).thenReturn(decisionServiceShapeView); control.register(element); verify(decisionServiceShapeView).addDividerDragHandler(dragHandlerCaptor.capture()); when(decisionServiceShapeView.getDividerLineY()).thenReturn(DIVIDER_Y); final DragHandler dragHandler = dragHandlerCaptor.getValue(); dragHandler.end(dragEvent); verify(canvasCommandFactory).updatePropertyValue(eq(element), eq(DIVIDER_Y_PROPERTY_ID), eq(DIVIDER_Y)); verify(commandManager).execute(eq(canvasHandler), eq(updateElementPropertyCommand)); }
|
DMNEditDRDToolboxAction implements ToolboxAction<AbstractCanvasHandler> { @Override public Glyph getGlyph(final AbstractCanvasHandler canvasHandler, final String uuid) { return ImageDataUriGlyph.create(StunnerCommonImageResources.INSTANCE.drd().getSafeUri()); } @Inject DMNEditDRDToolboxAction(final DRDContextMenu drdContextMenu); @Override Glyph getGlyph(final AbstractCanvasHandler canvasHandler, final String uuid); @Override String getTitle(final AbstractCanvasHandler canvasHandler, final String uuid); @Override ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler, final String uuid, final MouseClickEvent event); }
|
@Test public void testGetGlyph() { assertThat(dmnEditDRDToolboxAction.getGlyph(canvasHandler, UUID)).isNotNull(); assertThat(dmnEditDRDToolboxAction.getGlyph(canvasHandler, UUID)).isInstanceOf(ImageDataUriGlyph.class); }
|
DMNEditDRDToolboxAction implements ToolboxAction<AbstractCanvasHandler> { @Override public String getTitle(final AbstractCanvasHandler canvasHandler, final String uuid) { return drdContextMenu.getTitle(); } @Inject DMNEditDRDToolboxAction(final DRDContextMenu drdContextMenu); @Override Glyph getGlyph(final AbstractCanvasHandler canvasHandler, final String uuid); @Override String getTitle(final AbstractCanvasHandler canvasHandler, final String uuid); @Override ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler, final String uuid, final MouseClickEvent event); }
|
@Test public void testGetTitle() { final String title = "TITLE"; when(drdContextMenu.getTitle()).thenReturn(title); assertThat(dmnEditDRDToolboxAction.getTitle(canvasHandler, UUID)).isEqualTo(title); }
|
DMNEditDRDToolboxAction implements ToolboxAction<AbstractCanvasHandler> { @Override public ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler, final String uuid, final MouseClickEvent event) { drdContextMenu.appendContextMenuToTheDOM(event.getClientX(), event.getClientY()); final Element<? extends Definition<?>> element = CanvasLayoutUtils.getElement(canvasHandler, uuid); if (element instanceof Node) { drdContextMenu.show(singletonList(element.asNode())); } return this; } @Inject DMNEditDRDToolboxAction(final DRDContextMenu drdContextMenu); @Override Glyph getGlyph(final AbstractCanvasHandler canvasHandler, final String uuid); @Override String getTitle(final AbstractCanvasHandler canvasHandler, final String uuid); @Override ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler, final String uuid, final MouseClickEvent event); }
|
@Test public void testOnMouseClick() { final HTMLElement htmlElement = new HTMLElement(); htmlElement.style = new CSSStyleDeclaration(); final HTMLDocument htmlDocument = new HTMLDocument(); htmlDocument.body = new HTMLBodyElement(); Whitebox.setInternalState(DomGlobal.class, "document", htmlDocument); when(drdContextMenu.getElement()).thenReturn(htmlElement); dmnEditDRDToolboxAction.onMouseClick(canvasHandler, UUID, mouseClickEvent); verify(drdContextMenu, times(1)).show(any(Collection.class)); }
|
DMNEditDecisionToolboxAction implements ToolboxAction<AbstractCanvasHandler> { @Override public String getTitle(final AbstractCanvasHandler canvasHandler, final String uuid) { return translationService.getValue(CoreTranslationMessages.EDIT); } @Inject DMNEditDecisionToolboxAction(final SessionManager sessionManager,
final ClientTranslationService translationService,
final Event<EditExpressionEvent> editExpressionEvent); @Override Glyph getGlyph(final AbstractCanvasHandler canvasHandler,
final String uuid); @Override String getTitle(final AbstractCanvasHandler canvasHandler,
final String uuid); @Override @SuppressWarnings("unchecked") ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseClickEvent event); }
|
@Test public void testTitle() { tested.getTitle(canvasHandler, E_UUID); verify(translationService, times(1)).getValue(eq(CoreTranslationMessages.EDIT)); }
|
DMNEditDecisionToolboxAction implements ToolboxAction<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler, final String uuid, final MouseClickEvent event) { final Node<View<? extends Decision>, Edge> decisionNode = (Node<View<? extends Decision>, Edge>) CanvasLayoutUtils.getElement(canvasHandler, uuid) .asNode(); final Decision decision = (Decision) DefinitionUtils.getElementDefinition(decisionNode); final boolean isOnlyVisualChangeAllowed = decision.isAllowOnlyVisualChange(); editExpressionEvent.fire(new EditExpressionEvent(sessionManager.getCurrentSession(), uuid, decision, Optional.of(decision), isOnlyVisualChangeAllowed)); return this; } @Inject DMNEditDecisionToolboxAction(final SessionManager sessionManager,
final ClientTranslationService translationService,
final Event<EditExpressionEvent> editExpressionEvent); @Override Glyph getGlyph(final AbstractCanvasHandler canvasHandler,
final String uuid); @Override String getTitle(final AbstractCanvasHandler canvasHandler,
final String uuid); @Override @SuppressWarnings("unchecked") ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseClickEvent event); }
|
@Test public void testAction() { final MouseClickEvent event = mock(MouseClickEvent.class); final ToolboxAction<AbstractCanvasHandler> cascade = tested.onMouseClick(canvasHandler, E_UUID, event); assertEquals(tested, cascade); final ArgumentCaptor<EditExpressionEvent> eventCaptor = ArgumentCaptor.forClass(EditExpressionEvent.class); verify(editExpressionEvent, times(1)).fire(eventCaptor.capture()); final EditExpressionEvent editExprEvent = eventCaptor.getValue(); assertEquals(E_UUID, editExprEvent.getNodeUUID()); assertEquals(decision, editExprEvent.getHasExpression()); assertEquals(decision, editExprEvent.getHasName().get()); assertEquals(session, editExprEvent.getSession()); assertFalse(editExprEvent.isOnlyVisualChangeAllowed()); }
|
DMNEditBusinessKnowledgeModelToolboxAction implements ToolboxAction<AbstractCanvasHandler> { @Override public String getTitle(final AbstractCanvasHandler canvasHandler, final String uuid) { return translationService.getValue(CoreTranslationMessages.EDIT); } @Inject DMNEditBusinessKnowledgeModelToolboxAction(final SessionManager sessionManager,
final ClientTranslationService translationService,
final Event<EditExpressionEvent> editExpressionEvent); @Override Glyph getGlyph(final AbstractCanvasHandler canvasHandler,
final String uuid); @Override String getTitle(final AbstractCanvasHandler canvasHandler,
final String uuid); @Override @SuppressWarnings("unchecked") ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseClickEvent event); }
|
@Test public void testTitle() { tested.getTitle(canvasHandler, E_UUID); verify(translationService, times(1)).getValue(eq(CoreTranslationMessages.EDIT)); }
|
DMNEditBusinessKnowledgeModelToolboxAction implements ToolboxAction<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler, final String uuid, final MouseClickEvent event) { final Node<View<? extends BusinessKnowledgeModel>, Edge> bkmNode = (Node<View<? extends BusinessKnowledgeModel>, Edge>) CanvasLayoutUtils.getElement(canvasHandler, uuid) .asNode(); final BusinessKnowledgeModel bkm = (BusinessKnowledgeModel) DefinitionUtils.getElementDefinition(bkmNode); final boolean isOnlyVisualChangeAllowed = bkm.isAllowOnlyVisualChange(); editExpressionEvent.fire(new EditExpressionEvent(sessionManager.getCurrentSession(), uuid, bkm.asHasExpression(), Optional.of(bkm), isOnlyVisualChangeAllowed)); return this; } @Inject DMNEditBusinessKnowledgeModelToolboxAction(final SessionManager sessionManager,
final ClientTranslationService translationService,
final Event<EditExpressionEvent> editExpressionEvent); @Override Glyph getGlyph(final AbstractCanvasHandler canvasHandler,
final String uuid); @Override String getTitle(final AbstractCanvasHandler canvasHandler,
final String uuid); @Override @SuppressWarnings("unchecked") ToolboxAction<AbstractCanvasHandler> onMouseClick(final AbstractCanvasHandler canvasHandler,
final String uuid,
final MouseClickEvent event); }
|
@Test public void testAction() { final ToolboxAction<AbstractCanvasHandler> cascade = tested.onMouseClick(canvasHandler, E_UUID, mouseClickEvent); assertEquals(tested, cascade); final ArgumentCaptor<EditExpressionEvent> eventCaptor = ArgumentCaptor.forClass(EditExpressionEvent.class); verify(editExpressionEvent, times(1)).fire(eventCaptor.capture()); final EditExpressionEvent editExprEvent = eventCaptor.getValue(); assertEquals(E_UUID, editExprEvent.getNodeUUID()); final HasExpression hasExpression = editExprEvent.getHasExpression(); assertEquals(bkm.getEncapsulatedLogic(), hasExpression.getExpression()); assertEquals(bkm, hasExpression.asDMNModelInstrumentedBase()); assertFalse(hasExpression.isClearSupported()); assertEquals(bkm, editExprEvent.getHasName().get()); assertEquals(session, editExprEvent.getSession()); assertFalse(editExprEvent.isOnlyVisualChangeAllowed()); }
@Test public void testActionSetExpression() { tested.onMouseClick(canvasHandler, E_UUID, mouseClickEvent); final ArgumentCaptor<EditExpressionEvent> eventCaptor = ArgumentCaptor.forClass(EditExpressionEvent.class); verify(editExpressionEvent, times(1)).fire(eventCaptor.capture()); final EditExpressionEvent editExprEvent = eventCaptor.getValue(); final HasExpression hasExpression = editExprEvent.getHasExpression(); Assertions.assertThatThrownBy(() -> hasExpression.setExpression(new DecisionTable())) .isInstanceOf(UnsupportedOperationException.class) .hasMessage("It is not possible to set the EncapsulatedLogic of a BusinessKnowledgeModel."); }
|
DMNCommonActionsToolboxFactory extends CommonActionsToolboxFactory { @Override protected boolean isAllowed(final AbstractCanvasHandler canvasHandler, final Node node) { final Object content = node.getContent(); if (content instanceof Definition) { final Object definition = ((Definition) content).getDefinition(); if (definition instanceof DecisionService) { return true; } } return superIsAllowed(canvasHandler, node); } @Inject DMNCommonActionsToolboxFactory(final @Any ManagedInstance<DMNEditDecisionToolboxAction> editDecisionToolboxActions,
final @Any ManagedInstance<DMNEditBusinessKnowledgeModelToolboxAction> editBusinessKnowledgeModelToolboxActions,
final @Any ManagedInstance<DMNEditDRDToolboxAction> editDRDToolboxActions,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxView> views,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final @DMNEditor DefaultCanvasCommandFactory commandFactory,
final @DMNEditor ManagedInstance<DeleteNodeToolboxAction> deleteNodeActions,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override @SuppressWarnings("unchecked") Collection<ToolboxAction<AbstractCanvasHandler>> getActions(final AbstractCanvasHandler canvasHandler,
final Element<?> element); @PreDestroy void destroy(); }
|
@Test public void testIsAllowed() { final Node node = mock(Node.class); final Definition content = mock(Definition.class); final DecisionService decisionService = mock(DecisionService.class); when(node.getContent()).thenReturn(content); when(content.getDefinition()).thenReturn(decisionService); final boolean actual = tested.isAllowed(canvasHandler, node); assertTrue(actual); verify(tested, never()).superIsAllowed(canvasHandler, node); }
|
DMNCommonActionsToolboxFactory extends CommonActionsToolboxFactory { void addEditAction(final Element<?> element, final List<ToolboxAction<AbstractCanvasHandler>> actions) { if (isDecision(element)) { actions.add(editDecisionToolboxActions.get()); } else if (isBusinessKnowledgeModel(element)) { actions.add(editBusinessKnowledgeModelToolboxActions.get()); } } @Inject DMNCommonActionsToolboxFactory(final @Any ManagedInstance<DMNEditDecisionToolboxAction> editDecisionToolboxActions,
final @Any ManagedInstance<DMNEditBusinessKnowledgeModelToolboxAction> editBusinessKnowledgeModelToolboxActions,
final @Any ManagedInstance<DMNEditDRDToolboxAction> editDRDToolboxActions,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxView> views,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final @DMNEditor DefaultCanvasCommandFactory commandFactory,
final @DMNEditor ManagedInstance<DeleteNodeToolboxAction> deleteNodeActions,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override @SuppressWarnings("unchecked") Collection<ToolboxAction<AbstractCanvasHandler>> getActions(final AbstractCanvasHandler canvasHandler,
final Element<?> element); @PreDestroy void destroy(); }
|
@Test public void testAddEditDecisionAction() { final List<ToolboxAction<AbstractCanvasHandler>> actions = new ArrayList<>(); final Element element = mock(Element.class); final Node node = mock(Node.class); final Definition definition = mock(Definition.class); final Decision decision = mock(Decision.class); when(element.asNode()).thenReturn(node); when(element.getContent()).thenReturn(definition); when(definition.getDefinition()).thenReturn(decision); tested.addEditAction(element, actions); assertEquals(1, actions.size()); assertTrue(DMNEditDecisionToolboxAction.class.isInstance(actions.get(0))); }
@Test public void testAddEditBusinessKnowledgeModelAction() { final List<ToolboxAction<AbstractCanvasHandler>> actions = new ArrayList<>(); final Element element = mock(Element.class); final Node node = mock(Node.class); final Definition definition = mock(Definition.class); final BusinessKnowledgeModel bkm = mock(BusinessKnowledgeModel.class); when(element.asNode()).thenReturn(node); when(element.getContent()).thenReturn(definition); when(definition.getDefinition()).thenReturn(bkm); tested.addEditAction(element, actions); assertEquals(1, actions.size()); assertTrue(DMNEditBusinessKnowledgeModelToolboxAction.class.isInstance(actions.get(0))); }
@Test public void testAddEditWhenIsNotDecisionOrBusinessKnowledgeModelAction() { final List<ToolboxAction<AbstractCanvasHandler>> actions = new ArrayList<>(); final Element element = mock(Element.class); final Node node = mock(Node.class); final Definition definition = mock(Definition.class); final Object someObject = mock(Object.class); when(element.asNode()).thenReturn(node); when(element.getContent()).thenReturn(definition); when(definition.getDefinition()).thenReturn(someObject); tested.addEditAction(element, actions); assertEquals(0, actions.size()); }
|
DMNToolboxControl extends AbstractToolboxControl { @Override protected List<ActionsToolboxFactory> getFactories() { if (readonlyProvider.isReadOnlyDiagram()) { return Collections.singletonList(commonActionsToolboxFactories.get()); } else { return Arrays.asList(flowActionsToolboxFactories.get(), commonActionsToolboxFactories.get()); } } @Inject DMNToolboxControl(final @Any @DMNFlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @DMNCommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories,
final @Any @DMNEditor ReadOnlyProvider readOnlyProvider); @PreDestroy @Override void destroy(); }
|
@Test public void testRegisterTheRightFactories() { final List<ActionsToolboxFactory> factories = tested.getFactories(); assertNotNull(factories); assertEquals(2, factories.size()); assertEquals(flowActionsToolboxFactoryInstance, factories.get(0)); assertEquals(commonActionsToolboxFactoryInstance, factories.get(1)); }
@Test public void testGetFactoriesWhenIsReadOnlyDiagram() { when(readonlyProvider.isReadOnlyDiagram()).thenReturn(true); tested.getFactories(); verify(commonActionsToolboxFactory).get(); verify(flowActionsToolboxFactory, never()).get(); }
@Test public void testGetFactoriesWhenIsNotReadOnlyDiagram() { when(readonlyProvider.isReadOnlyDiagram()).thenReturn(false); tested.getFactories(); verify(commonActionsToolboxFactory).get(); verify(flowActionsToolboxFactory).get(); }
|
DomainObjectAwareLienzoMultipleSelectionControl extends LienzoMultipleSelectionControl<H> { @Override public SelectionControl<H, Element> select(final String uuid) { selectedDomainObject = Optional.empty(); return super.select(uuid); } @Inject DomainObjectAwareLienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final DRDContextMenu drdContextMenu); @Override Optional<Object> getSelectedItemDefinition(); @Override SelectionControl<H, Element> select(final String uuid); @Override void clear(); @Override void destroy(); }
|
@Test public void testSelectElement() { control.select(ELEMENT_UUID); assertElementSelected(); }
|
DomainObjectAwareLienzoMultipleSelectionControl extends LienzoMultipleSelectionControl<H> { @Override protected void handleCanvasElementSelectedEvent(final CanvasSelectionEvent event) { selectedDomainObject = Optional.empty(); super.handleCanvasElementSelectedEvent(event); } @Inject DomainObjectAwareLienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final DRDContextMenu drdContextMenu); @Override Optional<Object> getSelectedItemDefinition(); @Override SelectionControl<H, Element> select(final String uuid); @Override void clear(); @Override void destroy(); }
|
@Test public void testSelectElementWithEvent() { final CanvasSelectionEvent event = new CanvasSelectionEvent(canvasHandler, ELEMENT_UUID); control.handleCanvasElementSelectedEvent(event); assertElementSelected(); }
|
DomainObjectAwareLienzoMultipleSelectionControl extends LienzoMultipleSelectionControl<H> { void handleDomainObjectSelectedEvent(final @Observes DomainObjectSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { selectedDomainObject = Optional.ofNullable(event.getDomainObject()); } } @Inject DomainObjectAwareLienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final DRDContextMenu drdContextMenu); @Override Optional<Object> getSelectedItemDefinition(); @Override SelectionControl<H, Element> select(final String uuid); @Override void clear(); @Override void destroy(); }
|
@Test public void testSelectDomainObjectWithEvent() { final DomainObjectSelectionEvent event = new DomainObjectSelectionEvent(canvasHandler, domainObject); control.handleDomainObjectSelectedEvent(event); assertDomainObjectSelected(); }
|
DomainObjectAwareLienzoMultipleSelectionControl extends LienzoMultipleSelectionControl<H> { protected boolean isClickedOnShape(final H canvasHandler, final int canvasX, final int canvasY) { return getSelectedNodesStream(canvasHandler) .map(Element::getContent) .filter(content -> content instanceof View) .anyMatch(view -> { final Bounds bounds = ((View) view).getBounds(); return canvasX >= bounds.getUpperLeft().getX() && canvasX <= bounds.getLowerRight().getX() && canvasY >= bounds.getUpperLeft().getY() && canvasY <= bounds.getLowerRight().getY(); }); } @Inject DomainObjectAwareLienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final DRDContextMenu drdContextMenu); @Override Optional<Object> getSelectedItemDefinition(); @Override SelectionControl<H, Element> select(final String uuid); @Override void clear(); @Override void destroy(); }
|
@Test public void testIsClickedOnShapeWhenShapeIsNotClicked() { assertThat(control.isClickedOnShape(canvasHandler, 0, 0)).isFalse(); }
|
ObserverBuilderControl extends org.kie.workbench.common.stunner.core.client.canvas.controls.builder.impl.ObserverBuilderControl { @Override @SuppressWarnings("unchecked") protected void updateElementFromDefinition(final Element element, final Object definition) { final Object content = element.getContent(); if (!(content instanceof View)) { return; } final Object newDefinition = ((View) content).getDefinition(); if (newDefinition instanceof HasName && definition instanceof HasName) { ((HasName) newDefinition).getName().setValue(((HasName) definition).getName().getValue()); } if (newDefinition instanceof DynamicReadOnly && definition instanceof DynamicReadOnly) { ((DynamicReadOnly) newDefinition).setAllowOnlyVisualChange(((DynamicReadOnly) definition).isAllowOnlyVisualChange()); } if (newDefinition instanceof HasVariable && definition instanceof HasVariable) { ((HasVariable) newDefinition).setVariable(((HasVariable) definition).getVariable()); } if (newDefinition instanceof BusinessKnowledgeModel && definition instanceof BusinessKnowledgeModel) { ((BusinessKnowledgeModel) newDefinition).setEncapsulatedLogic(((BusinessKnowledgeModel) definition).getEncapsulatedLogic()); } if (newDefinition instanceof HasExpression && definition instanceof HasExpression) { ((HasExpression) newDefinition).setExpression(((HasExpression) definition).getExpression()); } if (newDefinition instanceof DMNElement && definition instanceof DMNElement) { final DMNElement dmnElement = (DMNElement) definition; if (!StringUtils.isEmpty(dmnElement.getId().getValue())) { ((DMNElement) newDefinition).getId().setValue(dmnElement.getId().getValue()); } } final Optional<DMNDiagramElement> currentDMNDiagramElement = getDMNDiagramsSession().getCurrentDMNDiagramElement(); if (currentDMNDiagramElement.isPresent() && newDefinition instanceof HasContentDefinitionId) { ((HasContentDefinitionId) newDefinition).setDiagramId(currentDMNDiagramElement.get().getId().getValue()); } } @Inject ObserverBuilderControl(final ClientDefinitionManager clientDefinitionManager,
final ClientFactoryService clientFactoryServices,
final RuleManager ruleManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final ClientTranslationMessages translationMessages,
final GraphBoundsIndexer graphBoundsIndexer,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final DMNDiagramsSession dmnDiagramsSession); }
|
@Test public void testUpdateNameFromDefinition() { final String expectedName = "expectedName"; final Element element = mock(Element.class); final View elementContent = mock(View.class); final HasName newDefinition = mock(HasName.class); final Name newDefinitionName = mock(Name.class); final HasName definition = mock(HasName.class); final Name definitionName = mock(Name.class); when(element.getContent()).thenReturn(elementContent); when(elementContent.getDefinition()).thenReturn(newDefinition); when(newDefinition.getName()).thenReturn(newDefinitionName); when(definition.getName()).thenReturn(definitionName); when(definitionName.getValue()).thenReturn(expectedName); observerBuilderControl.updateElementFromDefinition(element, definition); verify(newDefinitionName).setValue(expectedName); }
@Test public void testUpdateIdFromDefinition() { final String expectedId = "happyId"; final Element element = mock(Element.class); final View elementContent = mock(View.class); final DMNElement newDefinition = mock(DMNElement.class); final Id newDefinitionId = mock(Id.class); final DMNElement definition = mock(DMNElement.class); final Id definitionId = mock(Id.class); when(element.getContent()).thenReturn(elementContent); when(elementContent.getDefinition()).thenReturn(newDefinition); when(newDefinition.getId()).thenReturn(newDefinitionId); when(definition.getId()).thenReturn(definitionId); when(definitionId.getValue()).thenReturn(expectedId); observerBuilderControl.updateElementFromDefinition(element, definition); verify(newDefinitionId).setValue(expectedId); }
@Test public void testUpdateExpressionFromDefinition() { final Element element = mock(Element.class); final View elementContent = mock(View.class); final HasExpression newHasExpression = mock(HasExpression.class); final HasExpression hasExpression = mock(HasExpression.class); final Expression expression = mock(Expression.class); when(element.getContent()).thenReturn(elementContent); when(elementContent.getDefinition()).thenReturn(newHasExpression); when(hasExpression.getExpression()).thenReturn(expression); observerBuilderControl.updateElementFromDefinition(element, hasExpression); verify(newHasExpression).setExpression(expression); }
@Test public void testUpdateEncapsulatedLogicFromDefinition() { final Element element = mock(Element.class); final View elementContent = mock(View.class); final BusinessKnowledgeModel newBusinessKnowledgeModel = mock(BusinessKnowledgeModel.class); final BusinessKnowledgeModel businessKnowledgeModel = mock(BusinessKnowledgeModel.class); final FunctionDefinition functionDefinition = mock(FunctionDefinition.class); when(element.getContent()).thenReturn(elementContent); when(elementContent.getDefinition()).thenReturn(newBusinessKnowledgeModel); when(businessKnowledgeModel.getEncapsulatedLogic()).thenReturn(functionDefinition); when(newBusinessKnowledgeModel.getName()).thenReturn(new Name()); when(businessKnowledgeModel.getName()).thenReturn(new Name()); when(newBusinessKnowledgeModel.getId()).thenReturn(new Id()); when(businessKnowledgeModel.getId()).thenReturn(new Id()); observerBuilderControl.updateElementFromDefinition(element, businessKnowledgeModel); verify(newBusinessKnowledgeModel).setEncapsulatedLogic(functionDefinition); }
@Test @SuppressWarnings("unchecked") public void testUpdateVariableFromDefinition() { final Element element = mock(Element.class); final View elementContent = mock(View.class); final HasVariable newHasVariable = mock(HasVariable.class); final HasVariable hasVariable = mock(HasVariable.class); final IsInformationItem isInformationItem = mock(IsInformationItem.class); when(element.getContent()).thenReturn(elementContent); when(elementContent.getDefinition()).thenReturn(newHasVariable); when(hasVariable.getVariable()).thenReturn(isInformationItem); observerBuilderControl.updateElementFromDefinition(element, hasVariable); verify(newHasVariable).setVariable(isInformationItem); }
@Test public void testUpdateDMNDiagramIdFromSelectedDMNDiagram() { final DRGElement newDefinition = mock(DRGElement.class); final Element element = mock(Element.class); final View elementContent = mock(View.class); final Object definition = mock(Object.class); final String selectedDiagramId = "selected diagram id"; final DMNDiagramElement selectedDiagram = mock(DMNDiagramElement.class); final Id id = mock(Id.class); when(id.getValue()).thenReturn(selectedDiagramId); when(selectedDiagram.getId()).thenReturn(id); when(dmnDiagramsSession.getCurrentDMNDiagramElement()).thenReturn(Optional.of(selectedDiagram)); when(elementContent.getDefinition()).thenReturn(newDefinition); when(element.getContent()).thenReturn(elementContent); observerBuilderControl.updateElementFromDefinition(element, definition); verify(newDefinition).setDiagramId(selectedDiagramId); }
|
DRGElementTextPropertyProviderImpl implements TextPropertyProvider { @Override public int getPriority() { return 1; } DRGElementTextPropertyProviderImpl(); @Inject DRGElementTextPropertyProviderImpl(final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final DefinitionUtils definitionUtils); @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); }
|
@Test public void checkPriorityLessThanCatchAll() { assertTrue(provider.getPriority() < TextPropertyProviderFactory.CATCH_ALL_PRIORITY); }
|
DRGElementTextPropertyProviderImpl implements TextPropertyProvider { @Override public boolean supports(final Element<? extends Definition> element) { return DefinitionUtils.getElementDefinition(element) instanceof DRGElement; } DRGElementTextPropertyProviderImpl(); @Inject DRGElementTextPropertyProviderImpl(final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final DefinitionUtils definitionUtils); @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); }
|
@Test @SuppressWarnings("unchecked") public void checkSupportsDRGElement() { assertTrue(provider.supports(element)); final Element other = mock(Element.class); final Definition otherContent = mock(Definition.class); final TextAnnotation otherDefinition = mock(TextAnnotation.class); when(other.getContent()).thenReturn(otherContent); when(otherContent.getDefinition()).thenReturn(otherDefinition); assertFalse(provider.supports(other)); }
|
DRGElementTextPropertyProviderImpl implements TextPropertyProvider { @Override public String getText(final Element<? extends Definition> element) { final DRGElement drgElement = (DRGElement) DefinitionUtils.getElementDefinition(element); return drgElement.getNameHolder().getValue().getValue(); } DRGElementTextPropertyProviderImpl(); @Inject DRGElementTextPropertyProviderImpl(final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final DefinitionUtils definitionUtils); @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); }
|
@Test public void checkReadGetsTextFromNameProperty() { provider.getText(element); verify(definition).getNameHolder(); verify(nameHolder).getValue(); }
|
DRGElementTextPropertyProviderImpl implements TextPropertyProvider { @Override public void setText(final AbstractCanvasHandler canvasHandler, final CanvasCommandManager<AbstractCanvasHandler> commandManager, final Element<? extends Definition> element, final String text) { final Object definition = DefinitionUtils.getElementDefinition(element); final CanvasCommand<AbstractCanvasHandler> command = canvasCommandFactory.updatePropertyValue(element, definitionUtils.getNameIdentifier(definition), new Name(NameUtils.normaliseName(text))); commandManager.execute(canvasHandler, command); } DRGElementTextPropertyProviderImpl(); @Inject DRGElementTextPropertyProviderImpl(final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final DefinitionUtils definitionUtils); @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); }
|
@Test public void checkWriteUsesCommandToUpdateTextProperty() { provider.setText(canvasHandler, commandManager, element, NAME_VALUE); verify(canvasCommandFactory).updatePropertyValue(eq(element), eq(NAME_FIELD), nameArgumentCaptor.capture()); assertEquals(NAME_VALUE, nameArgumentCaptor.getValue().getValue()); verify(commandManager).execute(eq(canvasHandler), eq(command)); }
@Test public void checkWriteUsesCommandToUpdateTextPropertyWithWhitespace() { provider.setText(canvasHandler, commandManager, element, NAME_VALUE_WITH_WHITESPACE); verify(canvasCommandFactory).updatePropertyValue(eq(element), eq(NAME_FIELD), nameArgumentCaptor.capture()); assertEquals(NAME_VALUE, nameArgumentCaptor.getValue().getValue()); verify(commandManager).execute(eq(canvasHandler), eq(command)); }
|
DMNDiagramTextPropertyProviderImpl implements TextPropertyProvider { @Override public int getPriority() { return 1; } DMNDiagramTextPropertyProviderImpl(); @Inject DMNDiagramTextPropertyProviderImpl(final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final DefinitionUtils definitionUtils); @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); }
|
@Test public void checkPriorityLessThanCatchAll() { assertTrue(provider.getPriority() < TextPropertyProviderFactory.CATCH_ALL_PRIORITY); }
|
DMNDiagramTextPropertyProviderImpl implements TextPropertyProvider { @Override public boolean supports(final Element<? extends Definition> element) { return DefinitionUtils.getElementDefinition(element) instanceof DMNDiagram; } DMNDiagramTextPropertyProviderImpl(); @Inject DMNDiagramTextPropertyProviderImpl(final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final DefinitionUtils definitionUtils); @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); }
|
@Test @SuppressWarnings("unchecked") public void checkSupportsDMNDiagram() { assertTrue(provider.supports(element)); final Element other = mock(Element.class); final Definition otherContent = mock(Definition.class); final TextAnnotation otherDefinition = mock(TextAnnotation.class); when(other.getContent()).thenReturn(otherContent); when(otherContent.getDefinition()).thenReturn(otherDefinition); assertFalse(provider.supports(other)); }
|
DMNDiagramTextPropertyProviderImpl implements TextPropertyProvider { @Override public String getText(final Element<? extends Definition> element) { final DMNDiagram dmnDiagram = (DMNDiagram) DefinitionUtils.getElementDefinition(element); return dmnDiagram.getDefinitions().getNameHolder().getValue().getValue(); } DMNDiagramTextPropertyProviderImpl(); @Inject DMNDiagramTextPropertyProviderImpl(final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final DefinitionUtils definitionUtils); @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); }
|
@Test public void checkReadGetsTextFromNameProperty() { provider.getText(element); verify(definitions).getNameHolder(); verify(nameHolder).getValue(); }
|
DMNDiagramTextPropertyProviderImpl implements TextPropertyProvider { @Override public void setText(final AbstractCanvasHandler canvasHandler, final CanvasCommandManager<AbstractCanvasHandler> commandManager, final Element<? extends Definition> element, final String text) { final Object definition = ((DMNDiagram) DefinitionUtils.getElementDefinition(element)).getDefinitions(); final CanvasCommand<AbstractCanvasHandler> command = canvasCommandFactory.updatePropertyValue(element, definitionUtils.getNameIdentifier(definition), new Name(NameUtils.normaliseName(text))); commandManager.execute(canvasHandler, command); } DMNDiagramTextPropertyProviderImpl(); @Inject DMNDiagramTextPropertyProviderImpl(final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final DefinitionUtils definitionUtils); @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); }
|
@Test public void checkWriteUsesCommandToUpdateTextProperty() { provider.setText(canvasHandler, commandManager, element, NAME_VALUE); verify(canvasCommandFactory).updatePropertyValue(eq(element), eq(NAME_FIELD), nameArgumentCaptor.capture()); assertEquals(NAME_VALUE, nameArgumentCaptor.getValue().getValue()); verify(commandManager).execute(eq(canvasHandler), eq(command)); }
@Test public void checkWriteUsesCommandToUpdateTextPropertyWithWhitespace() { provider.setText(canvasHandler, commandManager, element, NAME_VALUE_WITH_WHITESPACE); verify(canvasCommandFactory).updatePropertyValue(eq(element), eq(NAME_FIELD), nameArgumentCaptor.capture()); assertEquals(NAME_VALUE, nameArgumentCaptor.getValue().getValue()); verify(commandManager).execute(eq(canvasHandler), eq(command)); }
|
TextAnnotationTextPropertyProviderImpl implements TextPropertyProvider { @Override public int getPriority() { return 0; } TextAnnotationTextPropertyProviderImpl(); @Inject TextAnnotationTextPropertyProviderImpl(final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final DefinitionUtils definitionUtils); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); @Override String getText(final Element<? extends Definition> element); }
|
@Test public void checkPriorityLessThanCatchAll() { assertTrue(provider.getPriority() < TextPropertyProviderFactory.CATCH_ALL_PRIORITY); }
|
TextAnnotationTextPropertyProviderImpl implements TextPropertyProvider { @Override public boolean supports(final Element<? extends Definition> element) { return DefinitionUtils.getElementDefinition(element) instanceof TextAnnotation; } TextAnnotationTextPropertyProviderImpl(); @Inject TextAnnotationTextPropertyProviderImpl(final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final DefinitionUtils definitionUtils); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); @Override String getText(final Element<? extends Definition> element); }
|
@Test @SuppressWarnings("unchecked") public void checkSupportsTextAnnotationElements() { assertTrue(provider.supports(element)); final Element other = mock(Element.class); final Definition otherContent = mock(Definition.class); final InputData otherDefinition = mock(InputData.class); when(other.getContent()).thenReturn(otherContent); when(otherContent.getDefinition()).thenReturn(otherDefinition); assertFalse(provider.supports(other)); }
|
TextAnnotationTextPropertyProviderImpl implements TextPropertyProvider { @Override public String getText(final Element<? extends Definition> element) { final TextAnnotation ta = (TextAnnotation) DefinitionUtils.getElementDefinition(element); final String text = ta.getText().getValue(); return text; } TextAnnotationTextPropertyProviderImpl(); @Inject TextAnnotationTextPropertyProviderImpl(final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final DefinitionUtils definitionUtils); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); @Override String getText(final Element<? extends Definition> element); }
|
@Test public void checkReadGetsTextFromTextProperty() { provider.getText(element); verify(text).getValue(); }
|
TextAnnotationTextPropertyProviderImpl implements TextPropertyProvider { @Override public void setText(final AbstractCanvasHandler canvasHandler, final CanvasCommandManager<AbstractCanvasHandler> commandManager, final Element<? extends Definition> element, final String text) { final Object definition = DefinitionUtils.getElementDefinition(element); final CanvasCommand<AbstractCanvasHandler> command = canvasCommandFactory.updatePropertyValue(element, definitionUtils.getNameIdentifier(definition), text); commandManager.execute(canvasHandler, command); } TextAnnotationTextPropertyProviderImpl(); @Inject TextAnnotationTextPropertyProviderImpl(final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final DefinitionUtils definitionUtils); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); @Override String getText(final Element<? extends Definition> element); }
|
@Test public void checkWriteUsesCommandToUpdateTextProperty() { provider.setText(canvasHandler, commandManager, element, NAME_VALUE); verify(canvasCommandFactory).updatePropertyValue(element, NAME_FIELD, NAME_VALUE); verify(commandManager).execute(eq(canvasHandler), eq(command)); }
|
QNameHolder implements DMNProperty { public QNameHolder copy() { return new QNameHolder(Optional.ofNullable(value).map(QName::copy).orElse(null)); } QNameHolder(); QNameHolder(final QName value); QNameHolder copy(); PropertyType getType(); QName getValue(); void setValue(final QName value); @Override boolean equals(final Object o); @Override int hashCode(); @Type
static final PropertyType type; }
|
@Test public void testCopy() { final QNameHolder source = new QNameHolder(BuiltInType.BOOLEAN.asQName()); final QNameHolder target = source.copy(); assertNotNull(target); assertEquals(BuiltInType.BOOLEAN.asQName(), target.getValue()); }
|
LocationURI implements DMNProperty { public LocationURI copy() { return new LocationURI(value); } LocationURI(); LocationURI(final String value); LocationURI copy(); String getValue(); void setValue(final String value); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test public void testCopy() { final LocationURI source = new LocationURI(LOCATION_URI); final LocationURI target = source.copy(); assertNotNull(target); assertEquals(LOCATION_URI, target.getValue()); }
|
NameFieldType implements FieldType { @Override public String getTypeName() { return NAME; } @Override String getTypeName(); static final String NAME; }
|
@Test public void testTypeName() { assertEquals(NameFieldType.NAME, new NameFieldType().getTypeName()); }
|
NameHolder implements DMNProperty { public Name getValue() { return value; } NameHolder(); NameHolder(final Name value); NameHolder copy(); Name getValue(); void setValue(final Name value); @Override boolean equals(final Object o); @Override int hashCode(); static final String DEFAULT_NAME; @Type
static final PropertyType type; }
|
@Test public void testDefaultConstructor() { assertNotNull(holder4.getValue()); assertEquals(NameHolder.DEFAULT_NAME, holder4.getValue().getValue()); }
@Test public void testGetValue() { assertEquals(NAME, holder1.getValue().getValue()); }
|
NameHolder implements DMNProperty { public void setValue(final Name value) { this.value = value; } NameHolder(); NameHolder(final Name value); NameHolder copy(); Name getValue(); void setValue(final Name value); @Override boolean equals(final Object o); @Override int hashCode(); static final String DEFAULT_NAME; @Type
static final PropertyType type; }
|
@Test public void testSetValue() { holder1.setValue(new Name()); assertEquals("", holder1.getValue().getValue()); }
|
NameHolder implements DMNProperty { @Override public boolean equals(final Object o) { if (this == o) { return true; } if (!(o instanceof NameHolder)) { return false; } final NameHolder name = (NameHolder) o; return Objects.equals(value, name.value); } NameHolder(); NameHolder(final Name value); NameHolder copy(); Name getValue(); void setValue(final Name value); @Override boolean equals(final Object o); @Override int hashCode(); static final String DEFAULT_NAME; @Type
static final PropertyType type; }
|
@Test public void testEquals() { assertEquals(holder1, holder1); assertEquals(holder1, holder2); assertNotEquals(holder1, holder3); assertNotEquals(holder2, holder3); assertNotEquals(holder1, "Cheese"); }
|
NameHolder implements DMNProperty { @Override public int hashCode() { return HashUtil.combineHashCodes(value != null ? value.hashCode() : 0); } NameHolder(); NameHolder(final Name value); NameHolder copy(); Name getValue(); void setValue(final Name value); @Override boolean equals(final Object o); @Override int hashCode(); static final String DEFAULT_NAME; @Type
static final PropertyType type; }
|
@Test public void testHashCode() { assertEquals(holder1.hashCode(), holder2.hashCode()); assertNotEquals(holder1.hashCode(), holder3.hashCode()); assertNotEquals(holder2.hashCode(), holder3.hashCode()); }
|
NameHolder implements DMNProperty { public NameHolder copy() { return new NameHolder(Optional.ofNullable(value).map(Name::copy).orElse(null)); } NameHolder(); NameHolder(final Name value); NameHolder copy(); Name getValue(); void setValue(final Name value); @Override boolean equals(final Object o); @Override int hashCode(); static final String DEFAULT_NAME; @Type
static final PropertyType type; }
|
@Test public void testCopy() { final NameHolder source = new NameHolder(new Name(NAME)); final NameHolder target = source.copy(); assertNotNull(target); assertEquals(NAME, target.getValue().getValue()); }
|
Question implements DMNProperty { public Question copy() { return new Question(value); } Question(); Question(final String value); Question copy(); String getValue(); void setValue(final String value); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test public void testCopy() { final Question source = new Question(QUESTION_VALUE); final Question target = source.copy(); assertNotNull(target); assertEquals(QUESTION_VALUE, target.getValue()); }
|
ExpressionLanguage implements DMNProperty { public String getValue() { return value; } ExpressionLanguage(); ExpressionLanguage(final String value); ExpressionLanguage copy(); String getValue(); void setValue(final String value); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test public void testZeroParameterConstructor() { this.expressionLanguage = new ExpressionLanguage(); assertEquals("", expressionLanguage.getValue()); }
@Test public void testOneParameterConstructor() { this.expressionLanguage = new ExpressionLanguage(VALUE); assertEquals(VALUE, expressionLanguage.getValue()); }
|
DMNPathsHelperImpl implements DMNPathsHelper { org.uberfire.java.nio.file.Path getStandaloneRootPath() { return convertPath(newPath(STANDALONE_FILE_NAME, STANDALONE_URI)); } DMNPathsHelperImpl(); @Inject DMNPathsHelperImpl(final RefactoringQueryService refactoringQueryService,
final DMNImportTypesHelper importTypesHelper,
final @Named("ioStrategy") IOService ioService); @Override List<Path> getModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getDMNModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getPMMLModelsPaths(final WorkspaceProject workspaceProject); @Override String getRelativeURI(final Path dmnModelPath,
final Path includedModelPath); }
|
@Test public void testGetStandaloneRootPath() { final Path path = mock(Path.class); final org.uberfire.java.nio.file.Path expectedPath = mock(org.uberfire.java.nio.file.Path.class); doReturn(path).when(pathsHelper).newPath(STANDALONE_FILE_NAME, STANDALONE_URI); doReturn(expectedPath).when(pathsHelper).convertPath(path); final org.uberfire.java.nio.file.Path actualPath = pathsHelper.getStandaloneRootPath(); assertEquals(expectedPath, actualPath); }
|
ExpressionLanguage implements DMNProperty { public ExpressionLanguage copy() { return new ExpressionLanguage(value); } ExpressionLanguage(); ExpressionLanguage(final String value); ExpressionLanguage copy(); String getValue(); void setValue(final String value); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test public void testCopy() { final ExpressionLanguage source = new ExpressionLanguage(VALUE); final ExpressionLanguage target = source.copy(); assertNotNull(target); assertEquals(VALUE, target.getValue()); }
|
ConstraintTypeDataProvider implements SelectorDataProvider { @Override public SelectorData getSelectorData(final FormRenderingContext context) { final Map<Object, String> values = new TreeMap<>(Comparator.comparing(o -> valuePosition.get(o))); Arrays.stream(ConstraintType.values()) .forEach(scope -> values.put(scope.value(), translationService.getTranslation(KEY_PREFIX + scope.value()))); values.put("", translationService.getTranslation(KEY_PREFIX + "selectType")); return new SelectorData(values, ConstraintType.EXPRESSION.value()); } @Inject ConstraintTypeDataProvider(final TranslationService translationService); @Override String getProviderName(); @Override SelectorData getSelectorData(final FormRenderingContext context); }
|
@Test public void testGetSelectorData() { assertConstraintTypeIsPresent(ConstraintType.EXPRESSION, values); assertConstraintTypeIsPresent(ConstraintType.ENUMERATION, values); assertConstraintTypeIsPresent(ConstraintType.RANGE, values); }
|
Name implements DMNProperty { public Name copy() { return new Name(value); } Name(); Name(final String value); Name copy(); String getValue(); void setValue(final String value); @Override boolean equals(final Object o); @Override int hashCode(); static final transient String DEFAULT_NAME; }
|
@Test public void testCopy() { final Name source = new Name(NAME_VALUE); final Name target = source.copy(); assertNotNull(target); assertEquals(NAME_VALUE, target.getValue()); }
|
Description implements DMNProperty { public Description copy() { return new Description(value); } Description(); Description(final String value); Description copy(); String getValue(); void setValue(final String value); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test public void testCopy() { final Description source = new Description(DESCRIPTION_VALUE); final Description target = source.copy(); assertNotNull(target); assertEquals(DESCRIPTION_VALUE, target.getValue()); }
|
NamePropertyType implements PropertyType { @Override public String getName() { return NAME; } @Override String getName(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); static final String NAME; }
|
@Test public void testName() { assertEquals(NamePropertyType.NAME, new NamePropertyType().getName()); }
|
NamePropertyType implements PropertyType { @Override public int hashCode() { return ~~getName().hashCode(); } @Override String getName(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); static final String NAME; }
|
@Test public void testEqualsIdentify() { assertEquals(p1, p1); assertEquals(p1, p2); assertEquals(p1.hashCode(), p2.hashCode()); }
|
QName implements DMNProperty { @Override public int hashCode() { return HashUtil.combineHashCodes(namespaceURI.hashCode(), localPart.hashCode()); } QName(); QName(final BuiltInType type); QName(final String namespaceURI,
final String localPart); QName(final String namespaceURI,
final String localPart,
final String prefix); QName copy(); String getNamespaceURI(); String getLocalPart(); String getPrefix(); @Override String toString(); @Override boolean equals(final Object o); @Override int hashCode(); static final String NULL_NS_URI; static final String DEFAULT_NS_PREFIX; }
|
@Test public void checkHashCode() { assertEquals(QNAME1.hashCode(), QNAME2.hashCode()); assertEquals(QNAME1.hashCode(), QNAME3.hashCode()); assertEquals(QNAME2.hashCode(), QNAME3.hashCode()); final HashSet<QName> qNames = new HashSet<>(); qNames.add(QNAME1); assertTrue(qNames.contains(QNAME2)); assertTrue(qNames.contains(QNAME3)); }
|
QName implements DMNProperty { public String getPrefix() { return prefix; } QName(); QName(final BuiltInType type); QName(final String namespaceURI,
final String localPart); QName(final String namespaceURI,
final String localPart,
final String prefix); QName copy(); String getNamespaceURI(); String getLocalPart(); String getPrefix(); @Override String toString(); @Override boolean equals(final Object o); @Override int hashCode(); static final String NULL_NS_URI; static final String DEFAULT_NS_PREFIX; }
|
@Test public void testZeroArgumentConstructor() { final QName implicitQName = new QName(); final QName explicitQName = new QName(QName.NULL_NS_URI, BuiltInType.UNDEFINED.getName(), DMNModelInstrumentedBase.Namespace.FEEL.getPrefix()); assertEquals(explicitQName, implicitQName); }
|
QName implements DMNProperty { public QName copy() { return new QName(namespaceURI, localPart, prefix); } QName(); QName(final BuiltInType type); QName(final String namespaceURI,
final String localPart); QName(final String namespaceURI,
final String localPart,
final String prefix); QName copy(); String getNamespaceURI(); String getLocalPart(); String getPrefix(); @Override String toString(); @Override boolean equals(final Object o); @Override int hashCode(); static final String NULL_NS_URI; static final String DEFAULT_NS_PREFIX; }
|
@Test public void testCopy() { final QName source = new QName(NAMESPACE_URI, LOCAL_PART, PREFIX); final QName target = source.copy(); assertNotNull(target); assertEquals(NAMESPACE_URI, target.getNamespaceURI()); assertEquals(LOCAL_PART, target.getLocalPart()); assertEquals(PREFIX, target.getPrefix()); }
|
Text implements DMNProperty { public Text copy() { return new Text(value); } Text(); Text(final String value); Text copy(); String getValue(); void setValue(final String value); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test public void testCopy() { final Text source = new Text(TEXT_VALUE); final Text target = source.copy(); assertNotNull(target); assertEquals(TEXT_VALUE, target.getValue()); }
|
DMNGridPanel extends GridLienzoPanel { @Override public void onResize() { doResize(() -> { updatePanelSize(); refreshScrollPosition(); final TransformMediator restriction = mousePanMediator.getTransformMediator(); final Transform transform = restriction.adjust(getDefaultGridLayer().getViewport().getTransform(), getDefaultGridLayer().getVisibleBounds()); getDefaultGridLayer().getViewport().setTransform(transform); getDefaultGridLayer().batch(); }); } DMNGridPanel(final DMNGridLayer gridLayer,
final RestrictedMousePanMediator mousePanMediator,
final ContextMenuHandler contextMenuHandler); @Override void onResize(); static final int LIENZO_PANEL_WIDTH; static final int LIENZO_PANEL_HEIGHT; }
|
@Test public void testOnResize() { gridPanel.onResize(); verify(gridPanel).updatePanelSize(); verify(gridPanel).refreshScrollPosition(); verify(viewport).setTransform(eq(newTransform)); verify(gridLayer, times(2)).batch(); }
|
QNamePropertyType implements PropertyType { @Override public String getName() { return NAME; } @Override String getName(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); static final String NAME; }
|
@Test public void testName() { assertEquals(QNamePropertyType.NAME, new QNamePropertyType().getName()); }
|
AllowedAnswers implements DMNProperty { public AllowedAnswers copy() { return new AllowedAnswers(value); } AllowedAnswers(); AllowedAnswers(final String value); AllowedAnswers copy(); String getValue(); void setValue(final String value); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test public void testCopy() { final AllowedAnswers source = new AllowedAnswers(ALLOWED_ANSWER_VALUE); final AllowedAnswers target = source.copy(); assertNotNull(target); assertEquals(ALLOWED_ANSWER_VALUE, target.getValue()); }
|
DMNDefinitionSetResourceType extends AbstractDefinitionSetResourceType { @Override public Category getCategory() { return this.category; } DMNDefinitionSetResourceType(); @Inject DMNDefinitionSetResourceType(final Decision category); @Override Category getCategory(); @Override String getShortName(); @Override String getDescription(); @Override String getSuffix(); @Override int getPriority(); @Override Class<?> getDefinitionSetType(); }
|
@Test public void testCategory() { assertTrue(resourceType.getCategory() instanceof Decision); }
|
DMNDefinitionSetResourceType extends AbstractDefinitionSetResourceType { @Override public String getShortName() { return NAME; } DMNDefinitionSetResourceType(); @Inject DMNDefinitionSetResourceType(final Decision category); @Override Category getCategory(); @Override String getShortName(); @Override String getDescription(); @Override String getSuffix(); @Override int getPriority(); @Override Class<?> getDefinitionSetType(); }
|
@Test public void testShortName() { assertEquals(DMNDefinitionSetResourceType.NAME, resourceType.getShortName()); }
|
DMNDefinitionSetResourceType extends AbstractDefinitionSetResourceType { @Override public String getDescription() { return DESCRIPTION; } DMNDefinitionSetResourceType(); @Inject DMNDefinitionSetResourceType(final Decision category); @Override Category getCategory(); @Override String getShortName(); @Override String getDescription(); @Override String getSuffix(); @Override int getPriority(); @Override Class<?> getDefinitionSetType(); }
|
@Test public void testDescription() { assertEquals(DMNDefinitionSetResourceType.DESCRIPTION, resourceType.getDescription()); }
|
DMNDefinitionSetResourceType extends AbstractDefinitionSetResourceType { @Override public String getSuffix() { return DMN_EXTENSION; } DMNDefinitionSetResourceType(); @Inject DMNDefinitionSetResourceType(final Decision category); @Override Category getCategory(); @Override String getShortName(); @Override String getDescription(); @Override String getSuffix(); @Override int getPriority(); @Override Class<?> getDefinitionSetType(); }
|
@Test public void testSuffix() { assertEquals(DMNDefinitionSetResourceType.DMN_EXTENSION, resourceType.getSuffix()); }
|
DMNDefinitionSetResourceType extends AbstractDefinitionSetResourceType { @Override public int getPriority() { return 0; } DMNDefinitionSetResourceType(); @Inject DMNDefinitionSetResourceType(final Decision category); @Override Category getCategory(); @Override String getShortName(); @Override String getDescription(); @Override String getSuffix(); @Override int getPriority(); @Override Class<?> getDefinitionSetType(); }
|
@Test public void testPriority() { assertEquals(0, resourceType.getPriority()); }
|
DMNDefinitionSetResourceType extends AbstractDefinitionSetResourceType { @Override public Class<?> getDefinitionSetType() { return DMNDefinitionSet.class; } DMNDefinitionSetResourceType(); @Inject DMNDefinitionSetResourceType(final Decision category); @Override Category getCategory(); @Override String getShortName(); @Override String getDescription(); @Override String getSuffix(); @Override int getPriority(); @Override Class<?> getDefinitionSetType(); }
|
@Test public void testDefinitionSetType() { assertEquals(DMNDefinitionSet.class, resourceType.getDefinitionSetType()); }
|
DMNImportTypes { public static DMNImportTypes determineImportType(final String namespace) { return importTypes .stream() .filter(importType -> importType.matchesNamespace(namespace)) .findFirst() .orElse(null); } private DMNImportTypes(final String fileExtension,
final String... namespaces); static DMNImportTypes determineImportType(final String namespace); String getFileExtension(); String getDefaultNamespace(); List<String> getNamespaces(); static final DMNImportTypes DMN; static final DMNImportTypes PMML; }
|
@Test public void testUnknown() { assertNull(DMNImportTypes.determineImportType("cheese")); }
|
DMNImportTypes { public List<String> getNamespaces() { return namespaces; } private DMNImportTypes(final String fileExtension,
final String... namespaces); static DMNImportTypes determineImportType(final String namespace); String getFileExtension(); String getDefaultNamespace(); List<String> getNamespaces(); static final DMNImportTypes DMN; static final DMNImportTypes PMML; }
|
@Test public void testGetNamespacesDMN() { final List<String> namespaces = DMNImportTypes.DMN.getNamespaces(); assertEquals(1, namespaces.size()); assertEquals("http: }
@Test public void testGetNamespacesPMML() { final List<String> namespaces = DMNImportTypes.PMML.getNamespaces(); assertEquals(7, namespaces.size()); assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("http: assertEquals("http: }
|
NameAndDataTypeColumnRenderer extends BaseGridColumnRenderer<InformationItemCell.HasNameCell> { @Override public Group renderCell(final GridCell<InformationItemCell.HasNameCell> cell, final GridBodyCellRenderContext context) { if (cell == null || cell.getValue() == null) { return null; } final InformationItemCell.HasNameCell hasNameCell = cell.getValue().getValue(); return hasNameCell.render(context); } NameAndDataTypeColumnRenderer(); @Override Group renderHeaderContent(final List<GridColumn.HeaderMetaData> headerMetaData,
final GridHeaderColumnRenderContext context,
final int headerRowIndex,
final double blockWidth,
final double rowHeight); @Override Group renderCell(final GridCell<InformationItemCell.HasNameCell> cell,
final GridBodyCellRenderContext context); }
|
@Test @SuppressWarnings("unchecked") public void testRenderCellWithValue() { this.cell = new BaseGridCell<>(new BaseGridCellValue<>(InformationItemCell.HasNameCell.wrap(TITLE))); assertThat(renderer.renderCell(cell, bodyContext)).isNotNull(); verify(text1).setText(eq(TITLE)); verify(text1).setX(BLOCK_WIDTH / 2); verify(text1).setY(ROW_HEIGHT / 2); }
|
DMNImportTypes { public String getDefaultNamespace() { return namespaces.get(namespaces.size() - 1); } private DMNImportTypes(final String fileExtension,
final String... namespaces); static DMNImportTypes determineImportType(final String namespace); String getFileExtension(); String getDefaultNamespace(); List<String> getNamespaces(); static final DMNImportTypes DMN; static final DMNImportTypes PMML; }
|
@Test public void testGetDefaultNameSpaceDMN() { assertEquals("http: }
@Test public void testGetDefaultNameSpacePMML() { assertEquals("http: }
|
PMMLParameterMetadata { public String getName() { return name; } PMMLParameterMetadata(final @MapsTo("name") String name); String getName(); }
|
@Test public void testGetters() { final PMMLParameterMetadata metadata = new PMMLParameterMetadata(PARAMETER_NAME); assertEquals(PARAMETER_NAME, metadata.getName()); }
|
PMMLIncludedModel extends BaseIncludedModel { public Integer getModelCount() { return modelCount; } PMMLIncludedModel(final @MapsTo("modelName") String modelName,
final @MapsTo("modelPackage") String modelPackage,
final @MapsTo("path") String path,
final @MapsTo("importType") String importType,
final @MapsTo("modelCount") Integer modelCount); Integer getModelCount(); }
|
@Test public void testGetters() { final PMMLIncludedModel model = new PMMLIncludedModel(MODEL_NAME, MODEL_PACKAGE, PATH, IMPORT_TYPE, MODELS_COUNT); assertEquals(MODEL_NAME, model.getModelName()); assertEquals(MODEL_PACKAGE, model.getModelPackage()); assertEquals(PATH, model.getPath()); assertEquals(IMPORT_TYPE, model.getImportType()); assertEquals(MODELS_COUNT, model.getModelCount()); }
|
DataObject { public String getClassNameWithoutPackage() { int lastIndex = 0; if (classType.contains(".")) { lastIndex = classType.lastIndexOf('.') + 1; } return classType.substring(lastIndex); } DataObject(); DataObject(final String classType); String getClassType(); void setClassType(final String classType); List<DataObjectProperty> getProperties(); void setProperties(final List<DataObjectProperty> properties); String getClassNameWithoutPackage(); }
|
@Test public void testExtractName() { final String name1 = "org.java.SomeClass"; final DataObject dataObject = new DataObject(name1); final String expected1 = "SomeClass"; final String actual1 = dataObject.getClassNameWithoutPackage(); assertEquals(expected1, actual1); final String name2 = "SomeOtherClass"; final String expected2 = "SomeOtherClass"; final DataObject dataObject2 = new DataObject(name2); final String actual2 = dataObject2.getClassNameWithoutPackage(); assertEquals(expected2, actual2); }
|
BuiltInTypeUtils { public static boolean isBuiltInType(final String type) { return builtInTypeNames() .anyMatch(builtInTypeName -> Objects.equals(builtInTypeName, type)); } static boolean isBuiltInType(final String type); static Optional<BuiltInType> findBuiltInTypeByName(final String name); }
|
@Test public void testIsDefaultWhenTypeIsDefault() { assertTrue(BuiltInTypeUtils.isBuiltInType("string")); }
@Test public void testIsDefaultWhenTypeIsDefaultWithAlternativeAlias() { assertTrue(BuiltInTypeUtils.isBuiltInType("dayTimeDuration")); }
@Test public void testIsNotDefaultWhenTypeIsDefaultWithAnUpperCaseCharacter() { assertFalse(BuiltInTypeUtils.isBuiltInType("String")); }
@Test public void testIsDefaultWhenTypeIsNull() { assertFalse(BuiltInTypeUtils.isBuiltInType(null)); }
@Test public void testIsDefaultWhenTypeIsNotDefault() { assertFalse(BuiltInTypeUtils.isBuiltInType("tAddress")); }
|
ListBoxDOMElement extends BaseDOMElement<String, ListBox> implements TakesValue<String>,
Focusable { @Override public void setValue(final String value) { this.originalValue = value; for (int i = 0; i < widget.getItemCount(); i++) { if (Objects.equals(widget.getItemText(i), value)) { widget.setSelectedIndex(i); break; } } } ListBoxDOMElement(final ListBox widget,
final GridLayer gridLayer,
final GridWidget gridWidget,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Function<GridCellTuple, Command> hasNoValueCommand,
final Function<GridCellValueTuple, Command> hasValueCommand); @Override void setValue(final String value); @Override String getValue(); @Override int getTabIndex(); @Override void setAccessKey(final char key); @Override void setFocus(final boolean focused); @Override void setTabIndex(final int index); @Override void initialise(final GridBodyCellRenderContext context); @Override @SuppressWarnings("unchecked") void flush(final String value); }
|
@Test public void testSetValue() { final List<String> values = new Lists.Builder<String>().add("value1").add("value2").add(VALUE).build(); final String[] varArgs = new String[values.size() - 1]; values.subList(1, values.size()).toArray(varArgs); when(widget.getItemCount()).thenReturn(values.size()); when(widget.getItemText(anyInt())).thenReturn(values.get(0), varArgs); domElement.setValue(VALUE); verify(widget).setSelectedIndex(values.indexOf(VALUE)); }
|
BuiltInTypeUtils { public static Optional<BuiltInType> findBuiltInTypeByName(final String name) { return getBuiltInTypeValuesStream() .filter(builtInType -> Arrays.asList(builtInType.getNames()).contains(name)) .findAny(); } static boolean isBuiltInType(final String type); static Optional<BuiltInType> findBuiltInTypeByName(final String name); }
|
@Test public void testFindBuiltInTypeByNameWhenItFinds() { assertTrue(BuiltInTypeUtils.findBuiltInTypeByName("boolean").isPresent()); assertEquals(BOOLEAN, BuiltInTypeUtils.findBuiltInTypeByName("boolean").get()); }
@Test public void testFindBuiltInTypeByNameWhenItDoesNotFind() { assertFalse(BuiltInTypeUtils.findBuiltInTypeByName("something").isPresent()); }
|
DMNDiagramUtils { public List<DRGElement> getDRGElements(final Diagram diagram) { return getDefinitionStream(diagram) .filter(d -> d instanceof DRGElement) .map(d -> (DRGElement) d) .collect(Collectors.toList()); } DMNDiagramUtils(); List<DRGElement> getDRGElements(final Diagram diagram); String getNamespace(final Diagram diagram); Definitions getDefinitions(final Diagram diagram); Stream<Object> getDefinitionStream(final Diagram diagram); @SuppressWarnings("unchecked") Stream<Node> getNodeStream(final Diagram diagram); }
|
@Test public void testGetNodes() { final DRGElement drgElement = mock(DRGElement.class); when(definition.getDefinition()).thenReturn(drgElement); final List<DRGElement> actualNodes = utils.getDRGElements(diagram); final List<DRGElement> expectedNodes = singletonList(drgElement); assertEquals(expectedNodes, actualNodes); }
|
DMNDiagramUtils { public Definitions getDefinitions(final Diagram diagram) { return getDefinitionStream(diagram) .filter(d -> d instanceof DMNDiagram) .map(d -> (DMNDiagram) d) .findFirst() .map(DMNDiagram::getDefinitions) .orElse(NONE); } DMNDiagramUtils(); List<DRGElement> getDRGElements(final Diagram diagram); String getNamespace(final Diagram diagram); Definitions getDefinitions(final Diagram diagram); Stream<Object> getDefinitionStream(final Diagram diagram); @SuppressWarnings("unchecked") Stream<Node> getNodeStream(final Diagram diagram); }
|
@Test public void testGetDefinitionsWithRootNode() { final DMNDiagram definition = new DMNDiagram(); graph.addNode(newNode(definition)); final Definitions definitions = utils.getDefinitions(diagram); assertNotNull(definitions); assertEquals(definition.getDefinitions(), definitions); }
@Test public void testGetDefinitionsWithMultipleRootNodes() { final Decision definition1 = new Decision(); final DMNDiagram definition2 = new DMNDiagram(); graph.addNode(newNode(definition1)); graph.addNode(newNode(definition2)); final Definitions definitions = utils.getDefinitions(diagram); assertNotNull(definitions); assertEquals(definition2.getDefinitions(), definitions); }
@Test public void testGetDefinitionsWithConnectedNodes() { final Decision definition1 = new Decision(); final DMNDiagram definition2 = new DMNDiagram(); final Node<View, Edge> node1 = newNode(definition1); final Node<View, Edge> node2 = newNode(definition2); final Edge<View, Node> edge = new EdgeImpl<>(UUID.uuid()); node1.getInEdges().add(edge); node2.getOutEdges().add(edge); edge.setSourceNode(node2); edge.setTargetNode(node1); graph.addNode(node1); graph.addNode(node2); final Definitions definitions = utils.getDefinitions(diagram); assertNotNull(definitions); assertEquals(definition2.getDefinitions(), definitions); }
@Test public void testGetDefinitionsWithNoNodes() { assertNull(utils.getDefinitions(diagram)); }
|
AcyclicDirectedGraphRule extends RuleExtensionHandler<AcyclicDirectedGraphRule, GraphConnectionContext> { @Override @SuppressWarnings("unchecked") public RuleViolations evaluate(final RuleExtension rule, final GraphConnectionContext context) { final GraphEvaluationState state = context.getState(); final Graph<?, Node> graph = (Graph<?, Node>) state.getGraph(); final Optional<Node<? extends View<?>, ? extends Edge>> oSource = context.getSource(); final Optional<Node<? extends View<?>, ? extends Edge>> oTarget = context.getTarget(); final Edge<? extends View<?>, ? extends Node> oConnector = context.getConnector(); final DefaultRuleViolations result = new DefaultRuleViolations(); if (!(oSource.isPresent() && oTarget.isPresent())) { return result; } final Node<?, Edge> source = (Node<?, Edge>) oSource.get(); final Node<?, Edge> target = (Node<?, Edge>) oTarget.get(); final Edge<?, Node> connector = (Edge<?, Node>) oConnector; try { final TreeWalkTraverseProcessor walker = getTreeWalker(source, target, connector); walker.traverse(graph, new TreeTraverseCallback<Graph, Node, Edge>() { final Set<Node> inProgress = new HashSet<>(); @Override public void startGraphTraversal(final Graph graph) { } @Override public boolean startNodeTraversal(final Node node) { if (inProgress.contains(node)) { throw new DirectedAcrylicGraphViolationException(); } inProgress.add(node); return true; } @Override public boolean startEdgeTraversal(final Edge edge) { return true; } @Override public void endNodeTraversal(final Node node) { inProgress.remove(node); } @Override public void endEdgeTraversal(final Edge edge) { } @Override public void endGraphTraversal() { } }); } catch (DirectedAcrylicGraphViolationException e) { result.addViolation(new RuleViolationImpl(ERROR_MESSAGE)); } return result; } @Override Class<AcyclicDirectedGraphRule> getExtensionType(); @Override Class<GraphConnectionContext> getContextType(); @Override boolean accepts(final RuleExtension rule,
final GraphConnectionContext context); @Override @SuppressWarnings("unchecked") RuleViolations evaluate(final RuleExtension rule,
final GraphConnectionContext context); }
|
@Test @SuppressWarnings("unchecked") public void checkCyclicalConnection() { final Node node1 = new NodeImpl<>("node1"); final Node node2 = new NodeImpl<>("node2"); final Edge c1 = new EdgeImpl<>("edge1"); node1.getOutEdges().add(c1); node2.getInEdges().add(c1); c1.setSourceNode(node1); c1.setTargetNode(node2); graph.addNode(node1); graph.addNode(node2); when(context.getSource()).thenReturn(Optional.of(node2)); when(context.getTarget()).thenReturn(Optional.of(node1)); when(context.getConnector()).thenReturn(connector); final RuleViolations result = check.evaluate(rule, context); assertNotNull(result); assertTrue(result.violations().iterator().hasNext()); final RuleViolation violation = result.violations().iterator().next(); assertNotNull(violation); assertTrue(violation.getArguments().isPresent()); assertEquals(1, violation.getArguments().get().length); assertEquals(AcyclicDirectedGraphRule.ERROR_MESSAGE, violation.getArguments().get()[0]); }
|
SingleConnectorPerTypeGraphRule extends RuleExtensionHandler<SingleConnectorPerTypeGraphRule, GraphConnectionContext> { @Override @SuppressWarnings("unchecked") public RuleViolations evaluate(final RuleExtension rule, final GraphConnectionContext context) { final Optional<Node<? extends View<?>, ? extends Edge>> oSource = context.getSource(); final Optional<Node<? extends View<?>, ? extends Edge>> oTarget = context.getTarget(); final DefaultRuleViolations result = new DefaultRuleViolations(); if (!(oSource.isPresent() && oTarget.isPresent())) { return result; } final Node<? extends View<?>, ? extends Edge> source = oSource.get(); final Node<? extends View<?>, ? extends Edge> target = oTarget.get(); final Edge<? extends View<?>, ? extends Node> connector = context.getConnector(); if (isConnectionAlreadyFormed(source, target, connector)) { result.addViolation(new RuleViolationImpl(ERROR_MESSAGE)); } return result; } @Override Class<SingleConnectorPerTypeGraphRule> getExtensionType(); @Override Class<GraphConnectionContext> getContextType(); @Override boolean accepts(final RuleExtension rule,
final GraphConnectionContext context); @Override @SuppressWarnings("unchecked") RuleViolations evaluate(final RuleExtension rule,
final GraphConnectionContext context); }
|
@Test @SuppressWarnings("unchecked") public void checkHasExistingConnection() { final Node node1 = new NodeImpl<>("node1"); final Node node2 = new NodeImpl<>("node2"); final Edge existingConnector = new EdgeImpl<>("edge1"); final ViewConnector existingConnectorView = mock(ViewConnector.class); existingConnector.setContent(existingConnectorView); when(existingConnectorView.getDefinition()).thenReturn(new Definition()); node1.getOutEdges().add(existingConnector); node2.getInEdges().add(existingConnector); existingConnector.setSourceNode(node1); existingConnector.setTargetNode(node2); graph.addNode(node1); graph.addNode(node2); when(context.getSource()).thenReturn(Optional.of(node1)); when(context.getTarget()).thenReturn(Optional.of(node2)); when(context.getConnector()).thenReturn(connector); final RuleViolations result = check.evaluate(rule, context); assertNotNull(result); assertTrue(result.violations().iterator().hasNext()); final RuleViolation violation = result.violations().iterator().next(); assertNotNull(violation); assertTrue(violation.getArguments().isPresent()); assertEquals(1, violation.getArguments().get().length); assertEquals(SingleConnectorPerTypeGraphRule.ERROR_MESSAGE, violation.getArguments().get()[0]); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.