method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
ListGrid extends BaseExpressionGrid<List, ListGridData, ListUIModelMapper> implements HasListSelectorControl { @Override public void onItemSelected(final ListSelectorItem item) { final ListSelectorTextItem li = (ListSelectorTextItem) item; li.getCommand().execute(); } ListGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final ListGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final ReadOnlyProvider readOnlyProvider); @Override ListUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override java.util.List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); }### Answer:
@Test public void testOnItemSelected() { setupGrid(); final Command command = mock(Command.class); final HasListSelectorControl.ListSelectorTextItem listSelectorItem = mock(HasListSelectorControl.ListSelectorTextItem.class); when(listSelectorItem.getCommand()).thenReturn(command); grid.onItemSelected(listSelectorItem); verify(command).execute(); } |
### Question:
ListGrid extends BaseExpressionGrid<List, ListGridData, ListUIModelMapper> implements HasListSelectorControl { void deleteRow(final int index) { getExpression().get().ifPresent(list -> { sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new DeleteListRowCommand(list, model, index, () -> resize(BaseExpressionGrid.RESIZE_EXISTING))); }); } ListGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final ListGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final ReadOnlyProvider readOnlyProvider); @Override ListUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override java.util.List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); }### Answer:
@Test public void testDeleteListRow() { setupGrid(); grid.deleteRow(0); verify(sessionCommandManager).execute(eq(canvasHandler), deleteListRowCommandCaptor.capture()); final DeleteListRowCommand deleteContextEntryCommand = deleteListRowCommandCaptor.getValue(); deleteContextEntryCommand.execute(canvasHandler); verify(parent).onResize(); verify(gridPanel).refreshScrollPosition(); verify(gridPanel).updatePanelSize(); verify(gridLayer).batch(redrawCommandCaptor.capture()); final GridLayerRedrawManager.PrioritizedCommand redrawCommand = redrawCommandCaptor.getValue(); redrawCommand.execute(); verify(gridLayer).draw(); } |
### Question:
ListGrid extends BaseExpressionGrid<List, ListGridData, ListUIModelMapper> implements HasListSelectorControl { void clearExpressionType(final int uiRowIndex) { final GridCellTuple gc = new GridCellTuple(uiRowIndex, ListUIModelMapperHelper.EXPRESSION_COLUMN_INDEX, this); getExpression().get().ifPresent(list -> { final HasExpression hasExpression = list.getExpression().get(uiRowIndex); sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new ClearExpressionTypeCommand(gc, hasExpression, uiModelMapper, () -> { resize(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM); selectExpressionEditorFirstCell(uiRowIndex, ListUIModelMapperHelper.EXPRESSION_COLUMN_INDEX); }, () -> { resize(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM); selectExpressionEditorFirstCell(uiRowIndex, ListUIModelMapperHelper.EXPRESSION_COLUMN_INDEX); })); }); } ListGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final ListGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final ReadOnlyProvider readOnlyProvider); @Override ListUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override java.util.List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); }### Answer:
@Test public void testClearExpressionType() { setupGrid(); final ClearExpressionTypeCommand clearExpressionTypeCommand = clearRowExpression(0); verify(grid).resize(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM); verify(gridLayer).select(undefinedExpressionEditor); verify(undefinedExpressionEditor).selectFirstCell(); verify(gridLayer).batch(redrawCommandCaptor.capture()); redrawCommandCaptor.getValue().execute(); verify(gridLayer).draw(); reset(grid, gridLayer); clearExpressionTypeCommand.undo(canvasHandler); assertThat(grid.getModel().getColumns().get(EXPRESSION_COLUMN_INDEX).getWidth()).isEqualTo(ExpressionEditorColumn.DEFAULT_WIDTH); verify(grid).resize(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM); verify(grid).selectExpressionEditorFirstCell(eq(0), eq(ListUIModelMapperHelper.EXPRESSION_COLUMN_INDEX)); verify(gridLayer).select(literalExpressionEditor); verify(literalExpressionEditor).selectFirstCell(); verify(gridLayer).batch(redrawCommandCaptor.capture()); assertThat(redrawCommandCaptor.getAllValues()).hasSize(2); redrawCommandCaptor.getAllValues().get(1).execute(); verify(gridLayer).draw(); } |
### Question:
ListUIModelMapperHelper { public static ListSection getSection(final int columnIndex) { switch (columnIndex) { case 0: return ListSection.ROW_INDEX; case 1: return ListSection.EXPRESSION; default: return ListSection.NONE; } } static ListSection getSection(final int columnIndex); static final int ROW_COLUMN_INDEX; static final int EXPRESSION_COLUMN_INDEX; }### Answer:
@Test public void testGetSectionNoneLessThanMinimum() { assertEquals(ListSection.NONE, getSection(ListUIModelMapperHelper.ROW_COLUMN_INDEX - 1)); }
@Test public void testGetSectionNoneMoreThanMaximum() { assertEquals(ListSection.NONE, getSection(ListUIModelMapperHelper.EXPRESSION_COLUMN_INDEX + 1)); }
@Test public void testGetSectionRowNumberColumn() { assertEquals(ListSection.ROW_INDEX, getSection(ListUIModelMapperHelper.ROW_COLUMN_INDEX)); }
@Test public void testGetSectionExpressionColumn() { assertEquals(ListSection.EXPRESSION, getSection(ListUIModelMapperHelper.EXPRESSION_COLUMN_INDEX)); } |
### Question:
ListGridData extends DelegatingGridData { @Override public void moveRowTo(final int index, final GridRow row) { moveRowsTo(index, Collections.singletonList(row)); } ListGridData(final DMNGridData delegate,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Supplier<Optional<org.kie.workbench.common.dmn.api.definition.model.List>> expression,
final Command canvasOperation); @Override void moveRowTo(final int index,
final GridRow row); @Override void moveRowsTo(final int index,
final List<GridRow> rows); }### Answer:
@Test public void testMoveRowTo() { uiModel.moveRowTo(0, gridRow); verify(sessionCommandManager).execute(eq(canvasHandler), any(MoveRowsCommand.class)); } |
### Question:
ListGridData extends DelegatingGridData { @Override public void moveRowsTo(final int index, final List<GridRow> rows) { expression.get().ifPresent(list -> sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new MoveRowsCommand(list, delegate, index, rows, canvasOperation))); } ListGridData(final DMNGridData delegate,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Supplier<Optional<org.kie.workbench.common.dmn.api.definition.model.List>> expression,
final Command canvasOperation); @Override void moveRowTo(final int index,
final GridRow row); @Override void moveRowsTo(final int index,
final List<GridRow> rows); }### Answer:
@Test public void testMoveRowsTo() { uiModel.moveRowsTo(0, Collections.singletonList(gridRow)); verify(sessionCommandManager).execute(eq(canvasHandler), any(MoveRowsCommand.class)); } |
### Question:
ListEditorDefinition extends BaseEditorDefinition<List, ListGridData> { @Override public ExpressionType getType() { return ExpressionType.LIST; } ListEditorDefinition(); @Inject ListEditorDefinition(final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final @DMNEditor Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override ExpressionType getType(); @Override String getName(); @Override Optional<List> getModelClass(); @Override void enrich(final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<List> expression); @Override @SuppressWarnings("unused") Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final boolean isOnlyVisualChangeAllowed,
final int nesting); }### Answer:
@Test public void testType() { assertThat(definition.getType()).isEqualTo(ExpressionType.LIST); } |
### Question:
ListEditorDefinition extends BaseEditorDefinition<List, ListGridData> { @Override public String getName() { return translationService.format(DMNEditorConstants.ExpressionEditor_ListType); } ListEditorDefinition(); @Inject ListEditorDefinition(final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final @DMNEditor Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override ExpressionType getType(); @Override String getName(); @Override Optional<List> getModelClass(); @Override void enrich(final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<List> expression); @Override @SuppressWarnings("unused") Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final boolean isOnlyVisualChangeAllowed,
final int nesting); }### Answer:
@Test public void testName() { assertThat(definition.getName()).isEqualTo(DMNEditorConstants.ExpressionEditor_ListType); } |
### Question:
ListEditorDefinition extends BaseEditorDefinition<List, ListGridData> { @Override public Optional<List> getModelClass() { return Optional.of(new List()); } ListEditorDefinition(); @Inject ListEditorDefinition(final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final @DMNEditor Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override ExpressionType getType(); @Override String getName(); @Override Optional<List> getModelClass(); @Override void enrich(final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<List> expression); @Override @SuppressWarnings("unused") Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final boolean isOnlyVisualChangeAllowed,
final int nesting); }### Answer:
@Test public void testModelDefinition() { final Optional<List> oModel = definition.getModelClass(); assertThat(oModel).isPresent(); } |
### Question:
ExpressionEditorDefinitions extends ArrayList<ExpressionEditorDefinition<Expression>> { public Optional<ExpressionEditorDefinition<Expression>> getExpressionEditorDefinition(final Optional<Expression> expression) { if (!expression.isPresent()) { return this.stream() .filter(ed -> !ed.getModelClass().isPresent()) .findFirst(); } else { return this.stream() .filter(ed -> ed.getModelClass().isPresent()) .filter(ed -> ed.getModelClass().get().getClass().equals(expression.get().getClass())) .findFirst(); } } Optional<ExpressionEditorDefinition<Expression>> getExpressionEditorDefinition(final Optional<Expression> expression); Optional<ExpressionEditorDefinition<Expression>> getExpressionEditorDefinition(final ExpressionType type); }### Answer:
@Test public void textLookupForUndefinedExpression() { assertEquals(definition3, definitions.getExpressionEditorDefinition(Optional.empty()).get()); }
@Test public void textLookupByExpressionClass() { assertEquals(definition1, definitions.getExpressionEditorDefinition(Optional.of(new LiteralExpression())).get()); assertEquals(definition2, definitions.getExpressionEditorDefinition(Optional.of(new Context())).get()); }
@Test public void textLookupByExpressionType() { assertEquals(definition1, definitions.getExpressionEditorDefinition(ExpressionType.LITERAL_EXPRESSION).get()); assertEquals(definition2, definitions.getExpressionEditorDefinition(ExpressionType.CONTEXT).get()); } |
### Question:
InvocationGridData extends DelegatingGridData { @Override public void moveRowTo(final int index, final GridRow row) { moveRowsTo(index, Collections.singletonList(row)); } InvocationGridData(final DMNGridData delegate,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Supplier<Optional<Invocation>> expression,
final Command canvasOperation); @Override void moveRowTo(final int index,
final GridRow row); @Override void moveRowsTo(final int index,
final List<GridRow> rows); }### Answer:
@Test public void testMoveRowTo() { uiModel.moveRowTo(0, gridRow); verify(sessionCommandManager).execute(eq(canvasHandler), any(MoveRowsCommand.class)); } |
### Question:
InvocationGridData extends DelegatingGridData { @Override public void moveRowsTo(final int index, final List<GridRow> rows) { expression.get().ifPresent(invocation -> { final AbstractCanvasHandler handler = (AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(); sessionCommandManager.execute(handler, new MoveRowsCommand(invocation, delegate, index, rows, canvasOperation)); }); } InvocationGridData(final DMNGridData delegate,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Supplier<Optional<Invocation>> expression,
final Command canvasOperation); @Override void moveRowTo(final int index,
final GridRow row); @Override void moveRowsTo(final int index,
final List<GridRow> rows); }### Answer:
@Test public void testMoveRowsTo() { uiModel.moveRowsTo(0, Collections.singletonList(gridRow)); verify(sessionCommandManager).execute(eq(canvasHandler), any(MoveRowsCommand.class)); } |
### Question:
InvocationColumnExpressionHeaderMetaData extends EditableTextHeaderMetaData<TextBox, TextBoxDOMElement> implements HasCellEditorControls,
HasListSelectorControl { @Override public Group render(final GridHeaderColumnRenderContext context, final double blockWidth, final double blockHeight) { return RendererUtils.getExpressionHeaderText(this, context); } InvocationColumnExpressionHeaderMetaData(final Supplier<String> titleGetter,
final Consumer<String> titleSetter,
final SingletonDOMElementFactory<TextBox, TextBoxDOMElement> factory,
final Optional<String> placeHolder,
final ListSelectorView.Presenter listSelector,
final BiFunction<Integer, Integer, List<HasListSelectorControl.ListSelectorItem>> listSelectorItemsSupplier,
final Consumer<HasListSelectorControl.ListSelectorItem> listSelectorItemConsumer); @Override Group render(final GridHeaderColumnRenderContext context,
final double blockWidth,
final double blockHeight); @Override Optional<String> getPlaceHolder(); @Override Optional<Editor> getEditor(); @Override List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); }### Answer:
@Test public void testRender() { headerMetaData.render(context, BLOCK_WIDTH, BLOCK_HEIGHT); verify(textMock).setText(title); verify(textMock).setX(RendererUtils.EXPRESSION_TEXT_PADDING); verify(textMock).setY(RendererUtils.EXPRESSION_TEXT_PADDING); verify(textMock).setTextAlign(TextAlign.LEFT); } |
### Question:
InvocationColumnExpressionHeaderMetaData extends EditableTextHeaderMetaData<TextBox, TextBoxDOMElement> implements HasCellEditorControls,
HasListSelectorControl { @Override public Optional<String> getPlaceHolder() { return placeHolder; } InvocationColumnExpressionHeaderMetaData(final Supplier<String> titleGetter,
final Consumer<String> titleSetter,
final SingletonDOMElementFactory<TextBox, TextBoxDOMElement> factory,
final Optional<String> placeHolder,
final ListSelectorView.Presenter listSelector,
final BiFunction<Integer, Integer, List<HasListSelectorControl.ListSelectorItem>> listSelectorItemsSupplier,
final Consumer<HasListSelectorControl.ListSelectorItem> listSelectorItemConsumer); @Override Group render(final GridHeaderColumnRenderContext context,
final double blockWidth,
final double blockHeight); @Override Optional<String> getPlaceHolder(); @Override Optional<Editor> getEditor(); @Override List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); }### Answer:
@Test public void testGetPlaceHolder() { assertThat(headerMetaData.getPlaceHolder()).isEqualTo(placeHolder); } |
### Question:
InvocationEditorDefinition extends BaseEditorDefinition<Invocation, InvocationGridData> { @Override public ExpressionType getType() { return ExpressionType.INVOCATION; } InvocationEditorDefinition(); @Inject InvocationEditorDefinition(final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final @DMNEditor Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override ExpressionType getType(); @Override String getName(); @Override Optional<Invocation> getModelClass(); @Override void enrich(final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<Invocation> expression); @Override Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final boolean isOnlyVisualChangeAllowed,
final int nesting); }### Answer:
@Test public void testType() { assertEquals(ExpressionType.INVOCATION, definition.getType()); } |
### Question:
InvocationEditorDefinition extends BaseEditorDefinition<Invocation, InvocationGridData> { @Override public String getName() { return translationService.format(DMNEditorConstants.ExpressionEditor_InvocationType); } InvocationEditorDefinition(); @Inject InvocationEditorDefinition(final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final @DMNEditor Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override ExpressionType getType(); @Override String getName(); @Override Optional<Invocation> getModelClass(); @Override void enrich(final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<Invocation> expression); @Override Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final boolean isOnlyVisualChangeAllowed,
final int nesting); }### Answer:
@Test public void testName() { assertEquals(DMNEditorConstants.ExpressionEditor_InvocationType, definition.getName()); } |
### Question:
InvocationEditorDefinition extends BaseEditorDefinition<Invocation, InvocationGridData> { @Override public Optional<Invocation> getModelClass() { return Optional.of(new Invocation()); } InvocationEditorDefinition(); @Inject InvocationEditorDefinition(final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final @DMNEditor Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override ExpressionType getType(); @Override String getName(); @Override Optional<Invocation> getModelClass(); @Override void enrich(final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<Invocation> expression); @Override Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final boolean isOnlyVisualChangeAllowed,
final int nesting); }### Answer:
@Test public void testModelDefinition() { final Optional<Invocation> oModel = definition.getModelClass(); assertTrue(oModel.isPresent()); } |
### Question:
InvocationDefaultValueUtilities { public static String getNewParameterName(final Invocation invocation) { return PREFIX + DefaultValueUtilities.getMaxUnusedIndex(invocation.getBinding().stream() .map(Binding::getParameter) .filter(informationItem -> informationItem != null) .map(InformationItem::getName) .filter(name -> name != null) .map(Name::getValue) .collect(Collectors.toList()), PREFIX); } static String getNewParameterName(final Invocation invocation); static final String PREFIX; }### Answer:
@Test public void testGetNewParameterName() { final Binding binding1 = new Binding() {{ setParameter(new InformationItem()); }}; invocation.getBinding().add(binding1); binding1.getParameter().getName().setValue(InvocationDefaultValueUtilities.getNewParameterName(invocation)); assertThat(binding1.getParameter().getName().getValue()).isEqualTo(InvocationDefaultValueUtilities.PREFIX + "1"); final Binding binding2 = new Binding() {{ setParameter(new InformationItem()); }}; invocation.getBinding().add(binding2); binding2.getParameter().getName().setValue(InvocationDefaultValueUtilities.getNewParameterName(invocation)); assertThat(binding2.getParameter().getName().getValue()).isEqualTo(InvocationDefaultValueUtilities.PREFIX + "2"); }
@Test public void testGetNewParameterNameWithExistingParameters() { final Binding binding1 = new Binding() {{ setParameter(new InformationItem()); }}; invocation.getBinding().add(binding1); binding1.getParameter().getName().setValue("binding"); final Binding binding2 = new Binding() {{ setParameter(new InformationItem()); }}; invocation.getBinding().add(binding2); binding2.getParameter().getName().setValue(InvocationDefaultValueUtilities.getNewParameterName(invocation)); assertThat(binding2.getParameter().getName().getValue()).isEqualTo(InvocationDefaultValueUtilities.PREFIX + "1"); }
@Test public void testGetNewParameterNameWithDeletion() { final Binding binding1 = new Binding() {{ setParameter(new InformationItem()); }}; invocation.getBinding().add(binding1); binding1.getParameter().getName().setValue(InvocationDefaultValueUtilities.getNewParameterName(invocation)); assertThat(binding1.getParameter().getName().getValue()).isEqualTo(InvocationDefaultValueUtilities.PREFIX + "1"); final Binding binding2 = new Binding() {{ setParameter(new InformationItem()); }}; invocation.getBinding().add(binding2); binding2.getParameter().getName().setValue(InvocationDefaultValueUtilities.getNewParameterName(invocation)); assertThat(binding2.getParameter().getName().getValue()).isEqualTo(InvocationDefaultValueUtilities.PREFIX + "2"); invocation.getBinding().remove(binding1); final Binding binding3 = new Binding() {{ setParameter(new InformationItem()); }}; invocation.getBinding().add(binding3); binding3.getParameter().getName().setValue(InvocationDefaultValueUtilities.getNewParameterName(invocation)); assertThat(binding3.getParameter().getName().getValue()).isEqualTo(InvocationDefaultValueUtilities.PREFIX + "3"); } |
### Question:
ImportConverter { public static org.kie.dmn.model.api.Import dmnFromWb(final Import wb) { final org.kie.dmn.model.api.Import result = new org.kie.dmn.model.v1_2.TImport(); result.setImportType(wb.getImportType()); result.setLocationURI(wb.getLocationURI().getValue()); result.setNamespace(wb.getNamespace()); final Map<javax.xml.namespace.QName, String> additionalAttributes = new HashMap<>(); for (Map.Entry<QName, String> entry : wb.getAdditionalAttributes().entrySet()) { QNamePropertyConverter.dmnFromWB(entry.getKey()) .ifPresent(qName -> additionalAttributes.put(qName, entry.getValue())); } result.setId(wb.getId().getValue()); result.setName(wb.getName().getValue()); result.setDescription(DescriptionPropertyConverter.dmnFromWB(wb.getDescription())); result.setAdditionalAttributes(additionalAttributes); wb.getNsContext().forEach((key, value) -> result.getNsContext().put(key, value)); return result; } static Import wbFromDMN(final org.kie.dmn.model.api.Import dmn,
final Definitions definitions,
final PMMLDocumentMetadata pmmlDocument); static org.kie.dmn.model.api.Import dmnFromWb(final Import wb); }### Answer:
@Test public void testDmnFromWb() { final org.kie.workbench.common.dmn.api.definition.model.Import wb = new org.kie.workbench.common.dmn.api.definition.model.Import(); final String key = "drools"; final String value = "http: wb.getNsContext().put(key, value); final org.kie.dmn.model.api.Import anImport = ImportConverter.dmnFromWb(wb); final Map<String, String> nsContext = anImport.getNsContext(); assertEquals(1, nsContext.size()); assertEquals(value, nsContext.get(key)); } |
### Question:
InvocationGrid extends BaseExpressionGrid<Invocation, InvocationGridData, InvocationUIModelMapper> implements HasListSelectorControl { @SuppressWarnings("unused") List<ListSelectorItem> getHeaderItems(final int uiHeaderRowIndex, final int uiHeaderColumnIndex) { final List<ListSelectorItem> items = new ArrayList<>(); items.add(ListSelectorHeaderItem.build(translationService.format(DMNEditorConstants.InvocationEditor_Header))); items.add(ListSelectorTextItem.build(translationService.format(DMNEditorConstants.InvocationEditor_InsertParameter), true, () -> { cellEditorControls.hide(); getExpression().get().ifPresent(e -> addParameterBinding(model.getRowCount())); })); return items; } InvocationGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final InvocationGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final ReadOnlyProvider readOnlyProvider); @Override InvocationUIModelMapper makeUiModelMapper(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testGetHeaderItemsRowNumberColumn() { setupGrid(0); assertDefaultHeaderListItems(grid.getHeaderItems(0, 0)); }
@Test public void testGetHeaderItemsNameColumn() { setupGrid(0); assertDefaultHeaderListItems(grid.getHeaderItems(0, 1)); }
@Test public void testGetHeaderItemsExpressionColumn() { setupGrid(0); assertDefaultHeaderListItems(grid.getHeaderItems(0, 2)); } |
### Question:
InvocationGrid extends BaseExpressionGrid<Invocation, InvocationGridData, InvocationUIModelMapper> implements HasListSelectorControl { @Override public void onItemSelected(final ListSelectorItem item) { final ListSelectorTextItem li = (ListSelectorTextItem) item; li.getCommand().execute(); } InvocationGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final InvocationGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final ReadOnlyProvider readOnlyProvider); @Override InvocationUIModelMapper makeUiModelMapper(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testOnItemSelected() { setupGrid(0); final Command command = mock(Command.class); final HasListSelectorControl.ListSelectorTextItem listSelectorItem = mock(HasListSelectorControl.ListSelectorTextItem.class); when(listSelectorItem.getCommand()).thenReturn(command); grid.onItemSelected(listSelectorItem); verify(command).execute(); } |
### Question:
InvocationGrid extends BaseExpressionGrid<Invocation, InvocationGridData, InvocationUIModelMapper> implements HasListSelectorControl { void addParameterBinding(final int index) { getExpression().get().ifPresent(invocation -> { final Binding binding = new Binding(); final InformationItem parameter = new InformationItem(); parameter.setName(new Name()); binding.setParameter(parameter); final CommandResult<CanvasViolation> result = sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new AddParameterBindingCommand(invocation, binding, model, new ExpressionEditorGridRow(), index, uiModelMapper, () -> resize(BaseExpressionGrid.RESIZE_EXISTING))); if (!CommandUtils.isError(result)) { selectCell(index, InvocationUIModelMapper.BINDING_PARAMETER_COLUMN_INDEX, false, false); startEditingCell(index, InvocationUIModelMapper.BINDING_PARAMETER_COLUMN_INDEX); } }); } InvocationGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final InvocationGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final ReadOnlyProvider readOnlyProvider); @Override InvocationUIModelMapper makeUiModelMapper(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testAddParameterBinding() { setupGrid(0); addParameterBinding(0); verify(parent).proposeContainingColumnWidth(eq(grid.getWidth() + grid.getPadding() * 2), eq(BaseExpressionGrid.RESIZE_EXISTING)); verify(gridLayer).batch(redrawCommandCaptor.capture()); verify(gridPanel).refreshScrollPosition(); verify(gridPanel).updatePanelSize(); final GridLayerRedrawManager.PrioritizedCommand redrawCommand = redrawCommandCaptor.getValue(); redrawCommand.execute(); verify(gridLayer).draw(); verify(headerEditor).bind(any(HasValueAndTypeRef.class), eq(0), eq(1)); verify(cellEditorControls).show(eq(headerEditor), anyInt(), anyInt()); }
@Test @SuppressWarnings("unchecked") public void testSelectMultipleParameterBindings() { setupGrid(0); addParameterBinding(0); reset(domainObjectSelectionEvent); grid.selectCell(0, InvocationUIModelMapper.BINDING_PARAMETER_COLUMN_INDEX, false, false); assertDomainObjectSelection(expression.get().getBinding().get(0).getVariable()); reset(domainObjectSelectionEvent); grid.selectCell(1, InvocationUIModelMapper.BINDING_PARAMETER_COLUMN_INDEX, false, true); assertNOPDomainObjectSelection(); } |
### Question:
InvocationGrid extends BaseExpressionGrid<Invocation, InvocationGridData, InvocationUIModelMapper> implements HasListSelectorControl { void deleteParameterBinding(final int index) { getExpression().get().ifPresent(invocation -> { sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new DeleteParameterBindingCommand(invocation, model, index, () -> resize(BaseExpressionGrid.RESIZE_EXISTING))); }); } InvocationGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final InvocationGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final ReadOnlyProvider readOnlyProvider); @Override InvocationUIModelMapper makeUiModelMapper(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testDeleteParameterBinding() { setupGrid(0); grid.deleteParameterBinding(0); verify(sessionCommandManager).execute(eq(canvasHandler), deleteParameterBindingCommandCaptor.capture()); final DeleteParameterBindingCommand deleteParameterBindingCommand = deleteParameterBindingCommandCaptor.getValue(); deleteParameterBindingCommand.execute(canvasHandler); verify(parent).onResize(); verify(gridPanel).refreshScrollPosition(); verify(gridPanel).updatePanelSize(); verify(gridLayer).batch(redrawCommandCaptor.capture()); final GridLayerRedrawManager.PrioritizedCommand redrawCommand = redrawCommandCaptor.getValue(); redrawCommand.execute(); verify(gridLayer).draw(); } |
### Question:
InvocationGrid extends BaseExpressionGrid<Invocation, InvocationGridData, InvocationUIModelMapper> implements HasListSelectorControl { void clearExpressionType(final int uiRowIndex) { final GridCellTuple gc = new GridCellTuple(uiRowIndex, InvocationUIModelMapper.BINDING_EXPRESSION_COLUMN_INDEX, this); getExpression().get().ifPresent(invocation -> { final HasExpression hasExpression = invocation.getBinding().get(uiRowIndex); sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new ClearExpressionTypeCommand(gc, hasExpression, uiModelMapper, () -> { resize(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM); selectExpressionEditorFirstCell(uiRowIndex, InvocationUIModelMapper.BINDING_EXPRESSION_COLUMN_INDEX); }, () -> { resize(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM); selectExpressionEditorFirstCell(uiRowIndex, InvocationUIModelMapper.BINDING_EXPRESSION_COLUMN_INDEX); })); }); } InvocationGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final InvocationGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final ReadOnlyProvider readOnlyProvider); @Override InvocationUIModelMapper makeUiModelMapper(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testClearExpressionType() { setupGrid(0); grid.clearExpressionType(0); verify(sessionCommandManager).execute(eq(canvasHandler), clearExpressionTypeCommandCaptor.capture()); final ClearExpressionTypeCommand clearExpressionTypeCommand = clearExpressionTypeCommandCaptor.getValue(); clearExpressionTypeCommand.execute(canvasHandler); verify(grid).resize(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM); verify(gridLayer).select(undefinedExpressionEditor); verify(undefinedExpressionEditor).selectFirstCell(); verify(gridLayer).batch(redrawCommandCaptor.capture()); redrawCommandCaptor.getValue().execute(); verify(gridLayer).draw(); reset(grid, gridLayer); clearExpressionTypeCommand.undo(canvasHandler); assertThat(grid.getModel().getColumns().get(2).getWidth()).isEqualTo(UndefinedExpressionColumn.DEFAULT_WIDTH); verify(grid).resize(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM); verify(grid).selectExpressionEditorFirstCell(eq(0), eq(InvocationUIModelMapper.BINDING_EXPRESSION_COLUMN_INDEX)); verify(gridLayer).select(undefinedExpressionEditor); verify(undefinedExpressionEditor, times(2)).selectFirstCell(); verify(gridLayer).batch(redrawCommandCaptor.capture()); assertThat(redrawCommandCaptor.getAllValues()).hasSize(2); redrawCommandCaptor.getAllValues().get(1).execute(); verify(gridLayer).draw(); } |
### Question:
InvocationUIModelMapper extends BaseUIModelMapper<Invocation> { @Override public void fromDMNModel(final int rowIndex, final int columnIndex) { dmnModel.get().ifPresent(invocation -> { switch (columnIndex) { case ROW_NUMBER_COLUMN_INDEX: uiModel.get().setCell(rowIndex, columnIndex, () -> new InvocationGridCell<>(new BaseGridCellValue<>(rowIndex + 1), listSelector)); uiModel.get().getCell(rowIndex, columnIndex).setSelectionStrategy(RowSelectionStrategy.INSTANCE); break; case BINDING_PARAMETER_COLUMN_INDEX: final InformationItem variable = invocation.getBinding().get(rowIndex).getParameter(); uiModel.get().setCell(rowIndex, columnIndex, () -> new InformationItemCell(() -> InformationItemCell.HasNameAndDataTypeCell.wrap(variable), listSelector)); break; case BINDING_EXPRESSION_COLUMN_INDEX: final Binding binding = invocation.getBinding().get(rowIndex); final Optional<Expression> expression = Optional.ofNullable(binding.getExpression()); final boolean isOnlyVisualChangeAllowed = this.isOnlyVisualChangeAllowedSupplier.get(); final Optional<ExpressionEditorDefinition<Expression>> expressionEditorDefinition = expressionEditorDefinitionsSupplier.get().getExpressionEditorDefinition(expression); expressionEditorDefinition.ifPresent(ed -> { final Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> editor = ed.getEditor(new GridCellTuple(rowIndex, columnIndex, gridWidget), Optional.empty(), binding, Optional.ofNullable(binding.getParameter()), isOnlyVisualChangeAllowed, nesting + 1); uiModel.get().setCell(rowIndex, columnIndex, () -> new InvocationGridCell<>(new ExpressionCellValue(editor), listSelector)); }); } }); } InvocationUIModelMapper(final GridWidget gridWidget,
final Supplier<GridData> uiModel,
final Supplier<Optional<Invocation>> dmnModel,
final Supplier<Boolean> isOnlyVisualChangeAllowedSupplier,
final Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ListSelectorView.Presenter listSelector,
final int nesting); @Override void fromDMNModel(final int rowIndex,
final int columnIndex); @Override @SuppressWarnings("unchecked") void toDMNModel(final int rowIndex,
final int columnIndex,
final Supplier<Optional<GridCellValue<?>>> cell); static final int ROW_NUMBER_COLUMN_INDEX; static final int BINDING_PARAMETER_COLUMN_INDEX; static final int BINDING_EXPRESSION_COLUMN_INDEX; }### Answer:
@Test public void testFromDMNModelRowNumber() { setup(false); mapper.fromDMNModel(0, 0); assertEquals(1, uiModel.getCell(0, 0).getValue().getValue()); assertEquals(RowSelectionStrategy.INSTANCE, uiModel.getCell(0, 0).getSelectionStrategy()); }
@Test public void testFromDMNModelBindingParameter() { setup(false); mapper.fromDMNModel(0, 1); assertEquals("p0", ((InformationItemCell.HasNameAndDataTypeCell) uiModel.getCell(0, 1).getValue().getValue()).getName().getValue()); } |
### Question:
InvocationUIModelMapper extends BaseUIModelMapper<Invocation> { @Override @SuppressWarnings("unchecked") public void toDMNModel(final int rowIndex, final int columnIndex, final Supplier<Optional<GridCellValue<?>>> cell) { dmnModel.get().ifPresent(invocation -> { switch (columnIndex) { case ROW_NUMBER_COLUMN_INDEX: break; case BINDING_PARAMETER_COLUMN_INDEX: invocation.getBinding() .get(rowIndex) .getParameter() .getName() .setValue(cell.get().orElse(new BaseGridCellValue<>("")).getValue().toString()); break; case BINDING_EXPRESSION_COLUMN_INDEX: cell.get().ifPresent(v -> { final ExpressionCellValue ecv = (ExpressionCellValue) v; ecv.getValue().ifPresent(beg -> { beg.getExpression().get().ifPresent(e -> invocation.getBinding() .get(rowIndex) .setExpression((Expression) e)); }); }); } }); } InvocationUIModelMapper(final GridWidget gridWidget,
final Supplier<GridData> uiModel,
final Supplier<Optional<Invocation>> dmnModel,
final Supplier<Boolean> isOnlyVisualChangeAllowedSupplier,
final Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ListSelectorView.Presenter listSelector,
final int nesting); @Override void fromDMNModel(final int rowIndex,
final int columnIndex); @Override @SuppressWarnings("unchecked") void toDMNModel(final int rowIndex,
final int columnIndex,
final Supplier<Optional<GridCellValue<?>>> cell); static final int ROW_NUMBER_COLUMN_INDEX; static final int BINDING_PARAMETER_COLUMN_INDEX; static final int BINDING_EXPRESSION_COLUMN_INDEX; }### Answer:
@Test public void testToDMNModelBindingParameter() { setup(false); cellValueSupplier = () -> Optional.of(new BaseGridCellValue<>("updated")); mapper.toDMNModel(0, 1, cellValueSupplier); assertEquals("updated", invocation.getBinding().get(0).getParameter().getName().getValue()); }
@Test public void testToDMNModelBindingExpression() { setup(false); cellValueSupplier = () -> Optional.of(new ExpressionCellValue(Optional.of(literalExpressionEditor))); mapper.toDMNModel(0, 2, cellValueSupplier); assertEquals(literalExpression, invocation.getBinding().get(0).getExpression()); } |
### Question:
LiteralExpressionColumn extends DMNSimpleGridColumn<LiteralExpressionGrid, String> implements HasSingletonDOMElementResource { @Override public void destroyResources() { super.destroyResources(); factory.destroyResources(); } LiteralExpressionColumn(final List<HeaderMetaData> headerMetaData,
final AutocompleteTextAreaDOMElementFactory factory,
final double width,
final LiteralExpressionGrid gridWidget); @Override void edit(final GridCell<String> cell,
final GridBodyCellRenderContext context,
final Consumer<GridCellValue<String>> callback); @Override void flush(); @Override void destroyResources(); @Override void setWidth(final double width); }### Answer:
@Test public void testHeaderDOMElementsAreDestroyed() { final MockHasDOMElementResourcesHeaderMetaData mockHeaderMetaData = mock(MockHasDOMElementResourcesHeaderMetaData.class); column.getHeaderMetaData().add(mockHeaderMetaData); column.destroyResources(); verify(mockHeaderMetaData).destroyResources(); } |
### Question:
LiteralExpressionCell extends BaseHasDynamicHeightCell<T> { @Override public Optional<Editor> getEditor() { return Optional.of(listSelector); } LiteralExpressionCell(final GridCellValue<T> value,
final ListSelectorView.Presenter listSelector,
final double lineHeight); @Override Optional<Editor> getEditor(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testGetEditor() { assertThat(cell.getEditor()).isNotEmpty(); assertThat(cell.getEditor().get()).isSameAs(listSelector); } |
### Question:
LiteralExpressionUIModelMapper extends BaseUIModelMapper<LiteralExpression> { @Override public void fromDMNModel(final int rowIndex, final int columnIndex) { dmnModel.get().ifPresent(literalExpression -> { uiModel.get().setCell(rowIndex, columnIndex, () -> new LiteralExpressionCell<>(new BaseGridCellValue<>(literalExpression.getText().getValue()), listSelector, lineHeight)); }); } LiteralExpressionUIModelMapper(final Supplier<GridData> uiModel,
final Supplier<Optional<LiteralExpression>> dmnModel,
final ListSelectorView.Presenter listSelector,
final double lineHeight); @Override void fromDMNModel(final int rowIndex,
final int columnIndex); @Override void toDMNModel(final int rowIndex,
final int columnIndex,
final Supplier<Optional<GridCellValue<?>>> cell); }### Answer:
@Test public void testFromDmn_Empty() { mapper.fromDMNModel(0, 0); assertEquals("", ((BaseGridCellValue) uiModel.getCell(0, 0).getValue()).getValue()); }
@Test public void testFromDmn_MultiByte() { literalExpression.getText().setValue("学校"); mapper.fromDMNModel(0, 0); assertEquals("学校", ((BaseGridCellValue) uiModel.getCell(0, 0).getValue()).getValue()); }
@Test public void testFromDmn_CellType() { mapper.fromDMNModel(0, 0); assertTrue(uiModel.getCell(0, 0) instanceof LiteralExpressionCell); } |
### Question:
LiteralExpressionUIModelMapper extends BaseUIModelMapper<LiteralExpression> { @Override public void toDMNModel(final int rowIndex, final int columnIndex, final Supplier<Optional<GridCellValue<?>>> cell) { dmnModel.get().ifPresent(literalExpression -> literalExpression.getText().setValue((String) cell.get().orElse(new BaseGridCellValue<>("")).getValue())); } LiteralExpressionUIModelMapper(final Supplier<GridData> uiModel,
final Supplier<Optional<LiteralExpression>> dmnModel,
final ListSelectorView.Presenter listSelector,
final double lineHeight); @Override void fromDMNModel(final int rowIndex,
final int columnIndex); @Override void toDMNModel(final int rowIndex,
final int columnIndex,
final Supplier<Optional<GridCellValue<?>>> cell); }### Answer:
@Test public void testToDmn_Null() { mapper.toDMNModel(0, 0, () -> Optional.of(new BaseGridCellValue<>(null))); assertNull(literalExpression.getText().getValue()); }
@Test public void testToDmn_Empty() { mapper.toDMNModel(0, 0, () -> Optional.of(new BaseGridCellValue<>(""))); assertEquals("", literalExpression.getText().getValue()); }
@Test public void testToDmn_MultiByte() { mapper.toDMNModel(0, 0, () -> Optional.of(new BaseGridCellValue<>("学校"))); assertEquals("学校", literalExpression.getText().getValue()); } |
### Question:
LiteralExpressionGrid extends BaseDelegatingExpressionGrid<LiteralExpression, DMNGridData, LiteralExpressionUIModelMapper> implements HasListSelectorControl { @Override public List<NodeMouseEventHandler> getNodeMouseClickEventHandlers(final GridSelectionManager selectionManager) { final List<NodeMouseEventHandler> handlers = new ArrayList<>(); handlers.add(new DelegatingGridWidgetCellSelectorMouseEventHandler(selectionManager, this::getParentInformation, () -> nesting)); handlers.add(new EditableHeaderGridWidgetEditCellMouseEventHandler()); return handlers; } LiteralExpressionGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final DMNGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final ReadOnlyProvider readOnlyProvider); @Override List<NodeMouseEventHandler> getNodeMouseClickEventHandlers(final GridSelectionManager selectionManager); @Override List<NodeMouseEventHandler> getNodeMouseDoubleClickEventHandlers(final GridSelectionManager selectionManager,
final GridPinnedModeManager pinnedModeManager); @Override LiteralExpressionUIModelMapper makeUiModelMapper(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override double getPadding(); @Override @SuppressWarnings("unused") void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testMouseClickEventHandlers() { setupGrid(0); final List<NodeMouseEventHandler> handlers = grid.getNodeMouseClickEventHandlers(selectionManager); assertThat(handlers).hasSize(2); assertThat(handlers.get(0)).isInstanceOf(DelegatingGridWidgetCellSelectorMouseEventHandler.class); assertThat(handlers.get(1)).isInstanceOf(EditableHeaderGridWidgetEditCellMouseEventHandler.class); } |
### Question:
LiteralExpressionEditorDefinition extends BaseEditorDefinition<LiteralExpression, DMNGridData> { @Override public ExpressionType getType() { return ExpressionType.LITERAL_EXPRESSION; } LiteralExpressionEditorDefinition(); @Inject LiteralExpressionEditorDefinition(final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override ExpressionType getType(); @Override String getName(); @Override Optional<LiteralExpression> getModelClass(); @Override Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final boolean isOnlyVisualChangeAllowed,
final int nesting); }### Answer:
@Test public void testType() { assertThat(definition.getType()).isEqualTo(ExpressionType.LITERAL_EXPRESSION); } |
### Question:
LiteralExpressionEditorDefinition extends BaseEditorDefinition<LiteralExpression, DMNGridData> { @Override public String getName() { return translationService.format(DMNEditorConstants.ExpressionEditor_LiteralExpressionType); } LiteralExpressionEditorDefinition(); @Inject LiteralExpressionEditorDefinition(final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override ExpressionType getType(); @Override String getName(); @Override Optional<LiteralExpression> getModelClass(); @Override Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final boolean isOnlyVisualChangeAllowed,
final int nesting); }### Answer:
@Test public void testName() { assertThat(definition.getName()).isEqualTo(DMNEditorConstants.ExpressionEditor_LiteralExpressionType); } |
### Question:
LiteralExpressionEditorDefinition extends BaseEditorDefinition<LiteralExpression, DMNGridData> { @Override public Optional<LiteralExpression> getModelClass() { return Optional.of(new LiteralExpression()); } LiteralExpressionEditorDefinition(); @Inject LiteralExpressionEditorDefinition(final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override ExpressionType getType(); @Override String getName(); @Override Optional<LiteralExpression> getModelClass(); @Override Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final boolean isOnlyVisualChangeAllowed,
final int nesting); }### Answer:
@Test public void testModelDefinition() { final Optional<LiteralExpression> oModel = definition.getModelClass(); assertThat(oModel).isPresent(); } |
### Question:
ContextEntryDefaultValueUtilities { public static String getNewContextEntryName(final Context context) { return PREFIX + DefaultValueUtilities.getMaxUnusedIndex(context.getContextEntry().stream() .map(ContextEntry::getVariable) .filter(informationItem -> informationItem != null) .map(InformationItem::getName) .filter(name -> name != null) .map(Name::getValue) .collect(Collectors.toList()), PREFIX); } static String getNewContextEntryName(final Context context); static final String PREFIX; }### Answer:
@Test public void testGetNewContextEntryName() { final ContextEntry contextEntry1 = new ContextEntry() {{ setVariable(new InformationItem()); }}; context.getContextEntry().add(contextEntry1); contextEntry1.getVariable().getName().setValue(ContextEntryDefaultValueUtilities.getNewContextEntryName(context)); assertThat(contextEntry1.getVariable().getName().getValue()).isEqualTo(ContextEntryDefaultValueUtilities.PREFIX + "1"); final ContextEntry contextEntry2 = new ContextEntry() {{ setVariable(new InformationItem()); }}; context.getContextEntry().add(contextEntry2); contextEntry2.getVariable().getName().setValue(ContextEntryDefaultValueUtilities.getNewContextEntryName(context)); assertThat(contextEntry2.getVariable().getName().getValue()).isEqualTo(ContextEntryDefaultValueUtilities.PREFIX + "2"); }
@Test public void testGetNewContextEntryNameWithExistingContextEntries() { final ContextEntry contextEntry1 = new ContextEntry() {{ setVariable(new InformationItem()); }}; context.getContextEntry().add(contextEntry1); contextEntry1.getVariable().getName().setValue("entry"); final ContextEntry contextEntry2 = new ContextEntry() {{ setVariable(new InformationItem()); }}; context.getContextEntry().add(contextEntry2); contextEntry2.getVariable().getName().setValue(ContextEntryDefaultValueUtilities.getNewContextEntryName(context)); assertThat(contextEntry2.getVariable().getName().getValue()).isEqualTo(ContextEntryDefaultValueUtilities.PREFIX + "1"); }
@Test public void testGetNewContextEntryNameWithDeletion() { final ContextEntry contextEntry1 = new ContextEntry() {{ setVariable(new InformationItem()); }}; context.getContextEntry().add(contextEntry1); contextEntry1.getVariable().getName().setValue(ContextEntryDefaultValueUtilities.getNewContextEntryName(context)); assertThat(contextEntry1.getVariable().getName().getValue()).isEqualTo(ContextEntryDefaultValueUtilities.PREFIX + "1"); final ContextEntry contextEntry2 = new ContextEntry() {{ setVariable(new InformationItem()); }}; context.getContextEntry().add(contextEntry2); contextEntry2.getVariable().getName().setValue(ContextEntryDefaultValueUtilities.getNewContextEntryName(context)); assertThat(contextEntry2.getVariable().getName().getValue()).isEqualTo(ContextEntryDefaultValueUtilities.PREFIX + "2"); context.getContextEntry().remove(contextEntry1); final ContextEntry contextEntry3 = new ContextEntry() {{ setVariable(new InformationItem()); }}; context.getContextEntry().add(contextEntry3); contextEntry3.getVariable().getName().setValue(ContextEntryDefaultValueUtilities.getNewContextEntryName(context)); assertThat(contextEntry3.getVariable().getName().getValue()).isEqualTo(ContextEntryDefaultValueUtilities.PREFIX + "3"); } |
### Question:
ContextGridData extends DelegatingGridData { @Override public void moveRowTo(final int index, final GridRow row) { moveRowsTo(index, Collections.singletonList(row)); } ContextGridData(final DMNGridData delegate,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Supplier<Optional<Context>> expression,
final Command canvasOperation); @Override void moveRowTo(final int index,
final GridRow row); @Override void moveRowsTo(final int index,
final List<GridRow> rows); }### Answer:
@Test public void testMoveRowToPermitted() { doReturn(GraphCommandResultBuilder.SUCCESS).when(sessionCommandManager).allow(eq(canvasHandler), any(MoveRowsCommand.class)); uiModel.moveRowTo(0, gridRow); verify(sessionCommandManager).execute(eq(canvasHandler), any(MoveRowsCommand.class)); }
@Test public void testMoveRowToNotPermitted() { doReturn(GraphCommandResultBuilder.failed()).when(sessionCommandManager).allow(eq(canvasHandler), any(MoveRowsCommand.class)); uiModel.moveRowTo(0, gridRow); verify(sessionCommandManager, never()).execute(any(AbstractCanvasHandler.class), any(MoveRowsCommand.class)); } |
### Question:
ContextGridData extends DelegatingGridData { @Override public void moveRowsTo(final int index, final List<GridRow> rows) { expression.get().ifPresent(context -> { final AbstractCanvasHandler handler = (AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(); final MoveRowsCommand command = new MoveRowsCommand(context, delegate, index, rows, canvasOperation); if (isAllowed(sessionCommandManager.allow(handler, command))) { sessionCommandManager.execute(handler, command); } }); } ContextGridData(final DMNGridData delegate,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Supplier<Optional<Context>> expression,
final Command canvasOperation); @Override void moveRowTo(final int index,
final GridRow row); @Override void moveRowsTo(final int index,
final List<GridRow> rows); }### Answer:
@Test public void testMoveRowsToPermitted() { doReturn(GraphCommandResultBuilder.SUCCESS).when(sessionCommandManager).allow(eq(canvasHandler), any(MoveRowsCommand.class)); uiModel.moveRowsTo(0, Collections.singletonList(gridRow)); verify(sessionCommandManager).execute(eq(canvasHandler), any(MoveRowsCommand.class)); }
@Test public void testMoveRowsToNotPermitted() { doReturn(GraphCommandResultBuilder.failed()).when(sessionCommandManager).allow(eq(canvasHandler), any(MoveRowsCommand.class)); uiModel.moveRowsTo(0, Collections.singletonList(gridRow)); verify(sessionCommandManager, never()).execute(any(AbstractCanvasHandler.class), any(MoveRowsCommand.class)); } |
### Question:
ExpressionEditorColumnRenderer extends BaseGridColumnRenderer<Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>>> { @Override public Group renderCell(final GridCell<Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>>> cell, final GridBodyCellRenderContext context) { if (cell == null || cell.getValue() == null) { return null; } final Group g = GWT.create(Group.class); if (cell.getValue() != null && cell.getValue() instanceof ExpressionCellValue) { final ExpressionCellValue ecv = (ExpressionCellValue) cell.getValue(); ecv.getValue().ifPresent(editor -> { g.add(editor.setX(editor.getPadding()).setY(editor.getPadding())); registry.register(editor); }); } return g; } ExpressionEditorColumnRenderer(final GridWidgetRegistry registry); @Override Group renderCell(final GridCell<Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>>> cell,
final GridBodyCellRenderContext context); }### Answer:
@Test public void testRenderCellNoDMNExpression() throws Exception { cell = new BaseGridCell<>(new BaseGridCellValue<>(Optional.of(widget))); renderer.renderCell(cell, context); verify(renderedGroup, never()).add(any()); }
@Test public void testRenderCellDMNExpression() throws Exception { cell = new BaseGridCell<>(new ExpressionCellValue(Optional.of(widget))); renderer.renderCell(cell, context); verify(renderedGroup).add(editorGroup); verify(registry).register(widget); } |
### Question:
ContextUIModelMapperHelper { public static ContextSection getSection(final int columnIndex) { int _columnIndex = columnIndex; if ((_columnIndex = _columnIndex - ROW_INDEX_COLUMN_COUNT) < 0) { return ContextSection.ROW_INDEX; } if ((_columnIndex = _columnIndex - NAME_COLUMN_COUNT) < 0) { return ContextSection.NAME; } if (_columnIndex - EXPRESSION_COLUMN_COUNT < 0) { return ContextSection.EXPRESSION; } return ContextSection.NONE; } static ContextSection getSection(final int columnIndex); static final int ROW_COLUMN_INDEX; static final int NAME_COLUMN_INDEX; static final int EXPRESSION_COLUMN_INDEX; }### Answer:
@Test public void testGetSectionNone() { assertEquals(ContextSection.NONE, getSection(ContextUIModelMapperHelper.EXPRESSION_COLUMN_INDEX + 1)); }
@Test public void testGetSectionRowNumberColumn() { assertEquals(ContextSection.ROW_INDEX, getSection(ContextUIModelMapperHelper.ROW_COLUMN_INDEX)); }
@Test public void testGetSectionNameColumn() { assertEquals(ContextSection.NAME, getSection(ContextUIModelMapperHelper.NAME_COLUMN_INDEX)); }
@Test public void testGetSectionExpressionColumn() { assertEquals(ContextSection.EXPRESSION, getSection(ContextUIModelMapperHelper.EXPRESSION_COLUMN_INDEX)); } |
### Question:
ContextGrid extends BaseExpressionGrid<Context, ContextGridData, ContextUIModelMapper> implements HasRowDragRestrictions,
HasListSelectorControl { @Override public boolean isRowDragPermitted(final GridWidgetDnDHandlersState state) { final GridWidgetHandlersOperation operation = state.getOperation(); if (operation == GridWidgetHandlersOperation.ROW_MOVE_PENDING) { final int lastRowIndex = model.getRowCount() - 1; final List<GridRow> rows = state.getActiveGridRows(); return !rows.contains(model.getRow(lastRowIndex)); } return true; } ContextGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final ContextGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final ReadOnlyProvider readOnlyProvider); @Override ContextUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override boolean isRowDragPermitted(final GridWidgetDnDHandlersState state); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testRowDragPermittedNotPendingRowMove() { setupGrid(0); doReturn(GridWidgetHandlersOperation.NONE).when(dndHandlersState).getOperation(); assertTrue(grid.isRowDragPermitted(dndHandlersState)); } |
### Question:
ContextEntryPropertyConverter { public static ContextEntry wbFromDMN(final org.kie.dmn.model.api.ContextEntry dmn, final BiConsumer<String, HasComponentWidths> hasComponentWidthsConsumer) { final InformationItem variable = InformationItemPropertyConverter.wbFromDMN(dmn.getVariable()); final Expression expression = ExpressionPropertyConverter.wbFromDMN(dmn.getExpression(), hasComponentWidthsConsumer); final ContextEntry result = new ContextEntry(); if (Objects.nonNull(variable)) { variable.setParent(result); } result.setVariable(variable); if (Objects.nonNull(expression)) { expression.setParent(result); } result.setExpression(expression); return result; } static ContextEntry wbFromDMN(final org.kie.dmn.model.api.ContextEntry dmn,
final BiConsumer<String, HasComponentWidths> hasComponentWidthsConsumer); static org.kie.dmn.model.api.ContextEntry dmnFromWB(final ContextEntry wb,
final Consumer<ComponentWidths> componentWidthsConsumer); }### Answer:
@Test public void testWBFromDMN() { final org.kie.dmn.model.api.ContextEntry dmn = new TContextEntry(); final org.kie.dmn.model.api.InformationItem informationItem = new TInformationItem(); dmn.setVariable(informationItem); final org.kie.dmn.model.api.LiteralExpression literalExpression = new TLiteralExpression(); literalExpression.setId(EXPRESSION_UUID); dmn.setExpression(literalExpression); final ContextEntry wb = ContextEntryPropertyConverter.wbFromDMN(dmn, hasComponentWidthsConsumer); assertThat(wb).isNotNull(); assertThat(wb.getVariable()).isNotNull(); assertThat(wb.getExpression()).isNotNull(); assertThat(wb.getExpression().getId().getValue()).isEqualTo(EXPRESSION_UUID); verify(hasComponentWidthsConsumer).accept(eq(EXPRESSION_UUID), hasComponentWidthsCaptor.capture()); final HasComponentWidths hasComponentWidths = hasComponentWidthsCaptor.getValue(); assertThat(hasComponentWidths).isNotNull(); assertThat(hasComponentWidths).isEqualTo(wb.getExpression()); } |
### Question:
DMNContentServiceImpl extends KieService<String> implements DMNContentService { @Override public PMMLDocumentMetadata loadPMMLDocumentMetadata(final Path path) { return pmmlIncludedDocumentFactory.getDocumentByPath(path); } @Inject DMNContentServiceImpl(final CommentedOptionFactory commentedOptionFactory,
final DMNIOHelper dmnIOHelper,
final DMNPathsHelper pathsHelper,
final PMMLIncludedDocumentFactory pmmlIncludedDocumentFactory); @Override String getContent(final Path path); @Override DMNContentResource getProjectContent(final Path path,
final String defSetId); @Override void saveContent(final Path path,
final String content,
final Metadata metadata,
final String comment); @Override List<Path> getModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getDMNModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getPMMLModelsPaths(final WorkspaceProject workspaceProject); @Override PMMLDocumentMetadata loadPMMLDocumentMetadata(final Path path); @Override String getSource(final Path path); }### Answer:
@Test public void testLoadPMMLDocumentMetadata() { final PMMLDocumentMetadata expected = mock(PMMLDocumentMetadata.class); when(pmmlIncludedDocumentFactory.getDocumentByPath(path)).thenReturn(expected); final PMMLDocumentMetadata actual = service.loadPMMLDocumentMetadata(path); assertEquals(expected, actual); } |
### Question:
ContextGrid extends BaseExpressionGrid<Context, ContextGridData, ContextUIModelMapper> implements HasRowDragRestrictions,
HasListSelectorControl { @SuppressWarnings("unused") List<ListSelectorItem> getHeaderItems(final int uiHeaderRowIndex, final int uiHeaderColumnIndex) { final List<ListSelectorItem> items = new ArrayList<>(); items.add(ListSelectorHeaderItem.build(translationService.format(DMNEditorConstants.ContextEditor_Header))); items.add(ListSelectorTextItem.build(translationService.format(DMNEditorConstants.ContextEditor_InsertContextEntry), true, () -> { cellEditorControls.hide(); getExpression().get().ifPresent(e -> addContextEntry(model.getRowCount() - 1)); })); return items; } ContextGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final ContextGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final ReadOnlyProvider readOnlyProvider); @Override ContextUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override boolean isRowDragPermitted(final GridWidgetDnDHandlersState state); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testGetHeaderItemsRowNumberColumn() { setupGrid(0); assertDefaultHeaderListItems(grid.getHeaderItems(0, 0)); }
@Test public void testGetHeaderItemsNameColumn() { setupGrid(0); assertDefaultHeaderListItems(grid.getHeaderItems(0, 1)); }
@Test public void testGetHeaderItemsExpressionColumn() { setupGrid(0); assertDefaultHeaderListItems(grid.getHeaderItems(0, 2)); } |
### Question:
ContextGrid extends BaseExpressionGrid<Context, ContextGridData, ContextUIModelMapper> implements HasRowDragRestrictions,
HasListSelectorControl { @Override public void onItemSelected(final ListSelectorItem item) { final ListSelectorTextItem li = (ListSelectorTextItem) item; li.getCommand().execute(); } ContextGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final ContextGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final ReadOnlyProvider readOnlyProvider); @Override ContextUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override boolean isRowDragPermitted(final GridWidgetDnDHandlersState state); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testOnItemSelected() { setupGrid(0); final Command command = mock(Command.class); final HasListSelectorControl.ListSelectorTextItem listSelectorItem = mock(HasListSelectorControl.ListSelectorTextItem.class); when(listSelectorItem.getCommand()).thenReturn(command); grid.onItemSelected(listSelectorItem); verify(command).execute(); } |
### Question:
ContextGrid extends BaseExpressionGrid<Context, ContextGridData, ContextUIModelMapper> implements HasRowDragRestrictions,
HasListSelectorControl { void addContextEntry(final int index) { getExpression().get().ifPresent(c -> { final ContextEntry ce = new ContextEntry(); final InformationItem informationItem = new InformationItem(); informationItem.setName(new Name()); ce.setVariable(informationItem); final CommandResult<CanvasViolation> result = sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new AddContextEntryCommand(c, ce, model, new ExpressionEditorGridRow(), index, uiModelMapper, () -> resize(BaseExpressionGrid.RESIZE_EXISTING))); if (!CommandUtils.isError(result)) { selectCell(index, ContextUIModelMapperHelper.NAME_COLUMN_INDEX, false, false); startEditingCell(index, ContextUIModelMapperHelper.NAME_COLUMN_INDEX); } }); } ContextGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final ContextGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final ReadOnlyProvider readOnlyProvider); @Override ContextUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override boolean isRowDragPermitted(final GridWidgetDnDHandlersState state); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testAddContextEntry() { setupGrid(0); addContextEntry(0); verify(parent).proposeContainingColumnWidth(eq(grid.getWidth() + grid.getPadding() * 2), eq(BaseExpressionGrid.RESIZE_EXISTING)); verify(gridLayer).batch(redrawCommandCaptor.capture()); verify(gridPanel).refreshScrollPosition(); verify(gridPanel).updatePanelSize(); final GridLayerRedrawManager.PrioritizedCommand redrawCommand = redrawCommandCaptor.getValue(); redrawCommand.execute(); verify(gridLayer).draw(); verify(headerEditor).bind(any(HasValueAndTypeRef.class), eq(0), eq(1)); verify(cellEditorControls).show(eq(headerEditor), anyInt(), anyInt()); }
@Test @SuppressWarnings("unchecked") public void testAddContextEntryAutoEditContextEntryName() { setupGrid(0); final InOrder inOrder = Mockito.inOrder(grid); addContextEntry(0); reset(sessionCommandManager); addContextEntry(1); inOrder.verify(grid).startEditingCell(0, ContextUIModelMapperHelper.NAME_COLUMN_INDEX); inOrder.verify(grid).startEditingCell(1, ContextUIModelMapperHelper.NAME_COLUMN_INDEX); } |
### Question:
ContextGrid extends BaseExpressionGrid<Context, ContextGridData, ContextUIModelMapper> implements HasRowDragRestrictions,
HasListSelectorControl { void deleteContextEntry(final int index) { getExpression().get().ifPresent(c -> { sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new DeleteContextEntryCommand(c, model, index, () -> resize(BaseExpressionGrid.RESIZE_EXISTING))); }); } ContextGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final ContextGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final ReadOnlyProvider readOnlyProvider); @Override ContextUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override boolean isRowDragPermitted(final GridWidgetDnDHandlersState state); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testDeleteContextEntry() { setupGrid(0); grid.deleteContextEntry(0); verify(sessionCommandManager).execute(eq(canvasHandler), deleteContextEntryCommandCaptor.capture()); final DeleteContextEntryCommand deleteContextEntryCommand = deleteContextEntryCommandCaptor.getValue(); deleteContextEntryCommand.execute(canvasHandler); verify(parent).onResize(); verify(gridPanel).refreshScrollPosition(); verify(gridPanel).updatePanelSize(); verify(gridLayer).batch(redrawCommandCaptor.capture()); final GridLayerRedrawManager.PrioritizedCommand redrawCommand = redrawCommandCaptor.getValue(); redrawCommand.execute(); verify(gridLayer).draw(); } |
### Question:
ContextGrid extends BaseExpressionGrid<Context, ContextGridData, ContextUIModelMapper> implements HasRowDragRestrictions,
HasListSelectorControl { void clearExpressionType(final int uiRowIndex) { final GridCellTuple gc = new GridCellTuple(uiRowIndex, ContextUIModelMapperHelper.EXPRESSION_COLUMN_INDEX, this); getExpression().get().ifPresent(context -> { final HasExpression hasExpression = context.getContextEntry().get(uiRowIndex); sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new ClearExpressionTypeCommand(gc, hasExpression, uiModelMapper, () -> { resize(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM); selectExpressionEditorFirstCell(uiRowIndex, ContextUIModelMapperHelper.EXPRESSION_COLUMN_INDEX); }, () -> { resize(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM); selectExpressionEditorFirstCell(uiRowIndex, ContextUIModelMapperHelper.EXPRESSION_COLUMN_INDEX); })); }); } ContextGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final ContextGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final ReadOnlyProvider readOnlyProvider); @Override ContextUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override boolean isRowDragPermitted(final GridWidgetDnDHandlersState state); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testClearExpressionType() { setupGrid(0); grid.clearExpressionType(0); verify(sessionCommandManager).execute(eq(canvasHandler), clearExpressionTypeCommandCaptor.capture()); final ClearExpressionTypeCommand clearExpressionTypeCommand = clearExpressionTypeCommandCaptor.getValue(); clearExpressionTypeCommand.execute(canvasHandler); verify(grid).resize(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM); verify(gridLayer).select(undefinedExpressionEditor); verify(undefinedExpressionEditor).selectFirstCell(); verify(gridLayer).batch(redrawCommandCaptor.capture()); redrawCommandCaptor.getValue().execute(); verify(gridLayer).draw(); reset(grid, gridLayer); clearExpressionTypeCommand.undo(canvasHandler); assertThat(grid.getModel().getColumns().get(2).getWidth()).isEqualTo(UndefinedExpressionColumn.DEFAULT_WIDTH); verify(grid).resize(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM); verify(grid).selectExpressionEditorFirstCell(eq(0), eq(ContextUIModelMapperHelper.EXPRESSION_COLUMN_INDEX)); verify(gridLayer).select(undefinedExpressionEditor); verify(undefinedExpressionEditor, times(2)).selectFirstCell(); verify(gridLayer).batch(redrawCommandCaptor.capture()); assertThat(redrawCommandCaptor.getAllValues()).hasSize(2); redrawCommandCaptor.getAllValues().get(1).execute(); verify(gridLayer).draw(); } |
### Question:
ContextEntryPropertyConverter { public static org.kie.dmn.model.api.ContextEntry dmnFromWB(final ContextEntry wb, final Consumer<ComponentWidths> componentWidthsConsumer) { final org.kie.dmn.model.api.ContextEntry result = new org.kie.dmn.model.v1_2.TContextEntry(); final org.kie.dmn.model.api.InformationItem variable = InformationItemPropertyConverter.dmnFromWB(wb.getVariable()); if (Objects.nonNull(variable)) { variable.setParent(result); } org.kie.dmn.model.api.Expression expression = ExpressionPropertyConverter.dmnFromWB(wb.getExpression(), componentWidthsConsumer); if (Objects.isNull(expression)) { final org.kie.dmn.model.v1_2.TLiteralExpression literalExpression = new org.kie.dmn.model.v1_2.TLiteralExpression(); literalExpression.setText(ContextEntry.DEFAULT_EXPRESSION_VALUE); expression = literalExpression; } expression.setParent(result); result.setVariable(variable); result.setExpression(expression); return result; } static ContextEntry wbFromDMN(final org.kie.dmn.model.api.ContextEntry dmn,
final BiConsumer<String, HasComponentWidths> hasComponentWidthsConsumer); static org.kie.dmn.model.api.ContextEntry dmnFromWB(final ContextEntry wb,
final Consumer<ComponentWidths> componentWidthsConsumer); }### Answer:
@Test public void testDMNFromWB() { final ContextEntry wb = new ContextEntry(); final InformationItem informationItem = new InformationItem(); wb.setVariable(informationItem); final LiteralExpression literalExpression = new LiteralExpression(); literalExpression.getComponentWidths().set(0, 200.0); literalExpression.getId().setValue(EXPRESSION_UUID); wb.setExpression(literalExpression); final org.kie.dmn.model.api.ContextEntry dmn = ContextEntryPropertyConverter.dmnFromWB(wb, componentWidthsConsumer); assertThat(dmn).isNotNull(); assertThat(dmn.getVariable()).isNotNull(); assertThat(dmn.getExpression()).isNotNull(); assertThat(dmn.getExpression().getId()).isEqualTo(EXPRESSION_UUID); verify(componentWidthsConsumer).accept(componentWidthsCaptor.capture()); final ComponentWidths componentWidths = componentWidthsCaptor.getValue(); assertThat(componentWidths).isNotNull(); assertThat(componentWidths.getDmnElementRef().getLocalPart()).isEqualTo(EXPRESSION_UUID); assertThat(componentWidths.getWidths().size()).isEqualTo(literalExpression.getRequiredComponentWidthCount()); assertThat(componentWidths.getWidths().get(0)).isEqualTo(200.0); }
@Test public void testDMNFromWBWithNullWBExpression() { final ContextEntry wb = new ContextEntry(); final InformationItem informationItem = new InformationItem(); wb.setVariable(informationItem); wb.setExpression(null); final org.kie.dmn.model.api.ContextEntry dmn = ContextEntryPropertyConverter.dmnFromWB(wb, componentWidthsConsumer); assertThat(dmn).isNotNull(); assertThat(dmn.getVariable()).isNotNull(); assertThat(dmn.getExpression()).isNotNull(); assertThat(dmn.getExpression()).isInstanceOf(org.kie.dmn.model.api.LiteralExpression.class); final org.kie.dmn.model.api.LiteralExpression literalExpression = (org.kie.dmn.model.api.LiteralExpression) dmn.getExpression(); assertThat(literalExpression.getText()).isEqualTo(ContextEntry.DEFAULT_EXPRESSION_VALUE); } |
### Question:
ContextGridCell extends DMNGridCell<T> { @Override public Optional<Editor> getEditor() { return Optional.of(listSelector); } ContextGridCell(final GridCellValue<T> value,
final ListSelectorView.Presenter listSelector); @Override Optional<Editor> getEditor(); }### Answer:
@Test public void testGetEditor() { assertThat(cell.getEditor()).isNotEmpty(); assertThat(cell.getEditor().get()).isSameAs(listSelector); } |
### Question:
ExpressionCellValue extends BaseGridCellValue<Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>>> { public Optional<Double> getMinimumWidth() { final Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> editor = getValue(); if (editor.isPresent()) { final BaseExpressionGrid beg = editor.get(); return Optional.of(beg.getMinimumWidth()); } return Optional.empty(); } ExpressionCellValue(final Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> editor); Optional<Double> getMinimumWidth(); }### Answer:
@Test public void testMinimumWidthWhenNoEditorSet() { setup(Optional.empty()); assertFalse(ecv.getMinimumWidth().isPresent()); }
@Test public void testMinimumWidthWhenEditorSet() { doReturn(100.0).when(editor).getMinimumWidth(); setup(Optional.of(editor)); final Optional<Double> oMinimumWidth = ecv.getMinimumWidth(); assertTrue(oMinimumWidth.isPresent()); assertEquals(100.0, oMinimumWidth.get(), 0.0); } |
### Question:
ExpressionEditorColumn extends DMNGridColumn<BaseGrid<? extends Expression>, Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>>> implements HasDOMElementResources { @Override public void setWidthInternal(final double width) { super.setWidth(width); updateWidthOfChildren(); } ExpressionEditorColumn(final GridWidgetRegistry registry,
final HeaderMetaData headerMetaData,
final double width,
final BaseGrid<? extends Expression> gridWidget); ExpressionEditorColumn(final GridWidgetRegistry registry,
final List<HeaderMetaData> headerMetaData,
final double width,
final BaseGrid<? extends Expression> gridWidget); protected ExpressionEditorColumn(final List<HeaderMetaData> headerMetaData,
final BaseGridColumnRenderer<Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>>> renderer,
final double width,
final BaseGrid<? extends Expression> gridWidget); @Override Double getMinimumWidth(); @Override void setWidth(final double width); @Override void setWidthInternal(final double width); @Override void edit(final GridCell<Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>>> cell,
final GridBodyCellEditContext context,
final Consumer<GridCellValue<Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>>>> callback); static final double DEFAULT_WIDTH; }### Answer:
@Test public void testUpdateInternalWidth() { gridData.appendColumn(column); gridData.appendRow(new BaseGridRow()); gridData.appendRow(new BaseGridRow()); gridData.appendRow(new BaseGridRow()); mockCells(0, 0, 100); mockCells(1, 0, 110); mockCells(2, 0, 50, 60); column.setWidthInternal(200D); assertThat(getColumnWidth(0, 0, 0)).isEqualTo(200D); assertThat(getColumnWidth(1, 0, 0)).isEqualTo(200D); assertThat(getColumnWidth(2, 0, 0)).isEqualTo(50D); assertThat(getColumnWidth(2, 0, 1)).isEqualTo(150D); }
@Test public void testUpdateInternalWidthNoCellsInMiddle() { gridData.appendColumn(column); gridData.appendRow(new BaseGridRow()); gridData.appendRow(new BaseGridRow()); gridData.appendRow(new BaseGridRow()); mockCells(0, 0, 100); mockCells(1, 0); mockCells(2, 0, 50, 60); column.setWidthInternal(200D); assertThat(getColumnWidth(0, 0, 0)).isEqualTo(200D); assertThat(getColumnWidth(2, 0, 0)).isEqualTo(50D); assertThat(getColumnWidth(2, 0, 1)).isEqualTo(150D); }
@Test public void testUpdateInternalWidthResizedToSmaller() { gridData.appendColumn(column); gridData.appendRow(new BaseGridRow()); gridData.appendRow(new BaseGridRow()); gridData.appendRow(new BaseGridRow()); mockCells(0, 0, 100); mockCells(1, 0, 30, 30, 30); mockCells(2, 0, 50, 60); column.setWidthInternal(80D); assertThat(getColumnWidth(0, 0, 0)).isEqualTo(80D); assertThat(getColumnWidth(1, 0, 0)).isEqualTo(30D); assertThat(getColumnWidth(1, 0, 1)).isEqualTo(30D); assertThat(getColumnWidth(1, 0, 2)).isEqualTo(20D); assertThat(getColumnWidth(2, 0, 0)).isEqualTo(50D); assertThat(getColumnWidth(2, 0, 1)).isEqualTo(30D); } |
### Question:
DMNExternalLinksToExtensionElements { static void loadExternalLinksFromExtensionElements(final org.kie.dmn.model.api.DRGElement source, final org.kie.workbench.common.dmn.api.definition.model.DRGElement target) { if (!Objects.isNull(source.getExtensionElements())) { for (final Object obj : source.getExtensionElements().getAny()) { if (obj instanceof ExternalLink) { final ExternalLink el = (ExternalLink) obj; final DMNExternalLink external = new DMNExternalLink(); external.setDescription(el.getName()); external.setUrl(el.getUrl()); target.getLinksHolder().getValue().addLink(external); } } } } }### Answer:
@Test public void testLoadExternalLinksFromExtensionElements() { final org.kie.dmn.model.api.DRGElement source = mock(org.kie.dmn.model.api.DRGElement.class); final org.kie.workbench.common.dmn.api.definition.model.DRGElement target = mock(org.kie.workbench.common.dmn.api.definition.model.DRGElement.class); final DMNElement.ExtensionElements extensionElements = mock(DMNElement.ExtensionElements.class); final List<Object> externalLinks = new ArrayList<>(); final String linkDescription1 = "l1"; final String url1 = "url1"; final ExternalLink external1 = createExternalLinkMock(linkDescription1, url1); externalLinks.add(external1); final String linkDescription2 = "l2"; final String url2 = "url2"; final ExternalLink external2 = createExternalLinkMock(linkDescription2, url2); externalLinks.add(external2); when(extensionElements.getAny()).thenReturn(externalLinks); when(source.getExtensionElements()).thenReturn(extensionElements); final DocumentationLinksHolder linksHolder = mock(DocumentationLinksHolder.class); final DocumentationLinks links = new DocumentationLinks(); when(linksHolder.getValue()).thenReturn(links); when(target.getLinksHolder()).thenReturn(linksHolder); loadExternalLinksFromExtensionElements(source, target); assertEquals(2, links.getLinks().size()); compare(links.getLinks().get(0), linkDescription1, url1); compare(links.getLinks().get(1), linkDescription2, url2); } |
### Question:
ContextEditorDefinition extends BaseEditorDefinition<Context, ContextGridData> { @Override public ExpressionType getType() { return ExpressionType.CONTEXT; } ContextEditorDefinition(); @Inject ContextEditorDefinition(final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final @DMNEditor Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override ExpressionType getType(); @Override String getName(); @Override Optional<Context> getModelClass(); @Override void enrich(final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<Context> expression); @Override Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final boolean isOnlyVisualChangeAllowed,
final int nesting); }### Answer:
@Test public void testType() { assertEquals(ExpressionType.CONTEXT, definition.getType()); } |
### Question:
ContextEditorDefinition extends BaseEditorDefinition<Context, ContextGridData> { @Override public String getName() { return translationService.format(DMNEditorConstants.ExpressionEditor_ContextExpressionType); } ContextEditorDefinition(); @Inject ContextEditorDefinition(final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final @DMNEditor Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override ExpressionType getType(); @Override String getName(); @Override Optional<Context> getModelClass(); @Override void enrich(final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<Context> expression); @Override Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final boolean isOnlyVisualChangeAllowed,
final int nesting); }### Answer:
@Test public void testName() { assertEquals(DMNEditorConstants.ExpressionEditor_ContextExpressionType, definition.getName()); } |
### Question:
ContextEditorDefinition extends BaseEditorDefinition<Context, ContextGridData> { @Override public Optional<Context> getModelClass() { return Optional.of(new Context()); } ContextEditorDefinition(); @Inject ContextEditorDefinition(final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final @DMNEditor Supplier<ExpressionEditorDefinitions> expressionEditorDefinitionsSupplier,
final ValueAndDataTypePopoverView.Presenter headerEditor,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override ExpressionType getType(); @Override String getName(); @Override Optional<Context> getModelClass(); @Override void enrich(final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<Context> expression); @Override Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final boolean isOnlyVisualChangeAllowed,
final int nesting); }### Answer:
@Test public void testModelDefinition() { final Optional<Context> oModel = definition.getModelClass(); assertTrue(oModel.isPresent()); } |
### Question:
DecisionTableGrid extends BaseExpressionGrid<DecisionTable, DecisionTableGridData, DecisionTableUIModelMapper> implements HasListSelectorControl,
HasHitPolicyControl { @Override public void setHitPolicy(final HitPolicy hitPolicy, final Command onSuccess) { getExpression().get().ifPresent(dtable -> { final CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation> commandBuilder = new CompositeCommand.Builder<>(); commandBuilder.addCommand(new SetBuiltinAggregatorCommand(dtable, null, gridLayer::batch)); commandBuilder.addCommand(new SetHitPolicyCommand(dtable, hitPolicy, () -> { gridLayer.batch(); onSuccess.execute(); })); sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), commandBuilder.build()); }); } DecisionTableGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final DecisionTableGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final HitPolicyPopoverView.Presenter hitPolicyEditor,
final ManagedInstance<ValueAndDataTypePopoverView.Presenter> headerEditors,
final ReadOnlyProvider readOnlyProvider); @Override DecisionTableUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override HitPolicy getHitPolicy(); @Override BuiltinAggregator getBuiltinAggregator(); @Override void setHitPolicy(final HitPolicy hitPolicy,
final Command onSuccess); @Override void setBuiltinAggregator(final BuiltinAggregator aggregator); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testColumn0MetaData() { setupGrid(makeHasNameForDecision(), 0); final GridColumn<?> column = grid.getModel().getColumns().get(0); final List<GridColumn.HeaderMetaData> header = column.getHeaderMetaData(); assertEquals(1, header.size()); assertTrue(header.get(0) instanceof RowNumberColumnHeaderMetaData); final RowNumberColumnHeaderMetaData md = (RowNumberColumnHeaderMetaData) header.get(0); expression.get().setHitPolicy(HitPolicy.FIRST); assertEquals("F", md.getTitle()); expression.get().setHitPolicy(HitPolicy.ANY); assertEquals("A", md.getTitle()); }
@Test public void testSetHitPolicy() { final HitPolicy hitPolicy = HitPolicy.ANY; setupGrid(makeHasNameForDecision(), 0); grid.setHitPolicy(hitPolicy, command); verify(sessionCommandManager).execute(eq(canvasHandler), setHitPolicyCommandCaptor.capture()); final CompositeCommand<AbstractCanvasHandler, CanvasViolation> setHitPolicyCommand = setHitPolicyCommandCaptor.getValue(); assertEquals(2, setHitPolicyCommand.getCommands().size()); assertTrue(setHitPolicyCommand.getCommands().get(0) instanceof SetBuiltinAggregatorCommand); assertTrue(setHitPolicyCommand.getCommands().get(1) instanceof SetHitPolicyCommand); setHitPolicyCommand.execute(canvasHandler); verify(gridLayer, atLeast(1)).batch(); verify(command).execute(); assertEquals(hitPolicy, expression.get().getHitPolicy()); assertNull(expression.get().getAggregation()); } |
### Question:
DMNExternalLinksToExtensionElements { static void loadExternalLinksIntoExtensionElements(final org.kie.workbench.common.dmn.api.definition.model.DRGElement source, final org.kie.dmn.model.api.DRGElement target) { if (Objects.isNull(source.getLinksHolder()) || Objects.isNull(source.getLinksHolder().getValue())) { return; } final DocumentationLinks links = source.getLinksHolder().getValue(); final DMNElement.ExtensionElements elements = getOrCreateExtensionElements(target); removeAllExistingLinks(elements); for (final DMNExternalLink link : links.getLinks()) { final ExternalLink external = new ExternalLink(); external.setName(link.getDescription()); external.setUrl(link.getUrl()); elements.getAny().add(external); } target.setExtensionElements(elements); } }### Answer:
@Test public void testLoadExternalLinksIntoExtensionElements() { final org.kie.workbench.common.dmn.api.definition.model.DRGElement source = mock(org.kie.workbench.common.dmn.api.definition.model.DRGElement.class); final org.kie.dmn.model.api.DRGElement target = mock(org.kie.dmn.model.api.DRGElement.class); final DocumentationLinksHolder linksHolder = mock(DocumentationLinksHolder.class); when(source.getLinksHolder()).thenReturn(linksHolder); final DocumentationLinks documentationLinks = new DocumentationLinks(); final String url1 = "url1"; final String description1 = "desc1"; final org.kie.workbench.common.dmn.api.property.dmn.DMNExternalLink link1 = createWBExternalLinkMock(description1, url1); documentationLinks.addLink(link1); final String url2 = "url2"; final String description2 = "desc2"; final org.kie.workbench.common.dmn.api.property.dmn.DMNExternalLink link2 = createWBExternalLinkMock(description2, url2); documentationLinks.addLink(link2); when(linksHolder.getValue()).thenReturn(documentationLinks); final DMNElement.ExtensionElements extensionElements = mock(DMNElement.ExtensionElements.class); when(target.getExtensionElements()).thenReturn(extensionElements); final List<Object> externalLinks = new ArrayList<>(); when(extensionElements.getAny()).thenReturn(externalLinks); loadExternalLinksIntoExtensionElements(source, target); assertEquals(2, externalLinks.size()); compare((ExternalLink) externalLinks.get(0), description1, url1); compare((ExternalLink) externalLinks.get(1), description2, url2); } |
### Question:
DecisionTableGrid extends BaseExpressionGrid<DecisionTable, DecisionTableGridData, DecisionTableUIModelMapper> implements HasListSelectorControl,
HasHitPolicyControl { @Override public void onItemSelected(final ListSelectorItem item) { final ListSelectorTextItem li = (ListSelectorTextItem) item; li.getCommand().execute(); } DecisionTableGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final DecisionTableGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final HitPolicyPopoverView.Presenter hitPolicyEditor,
final ManagedInstance<ValueAndDataTypePopoverView.Presenter> headerEditors,
final ReadOnlyProvider readOnlyProvider); @Override DecisionTableUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override HitPolicy getHitPolicy(); @Override BuiltinAggregator getBuiltinAggregator(); @Override void setHitPolicy(final HitPolicy hitPolicy,
final Command onSuccess); @Override void setBuiltinAggregator(final BuiltinAggregator aggregator); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testOnItemSelected() { setupGrid(makeHasNameForDecision(), 0); final Command command = mock(Command.class); final HasListSelectorControl.ListSelectorTextItem listSelectorItem = mock(HasListSelectorControl.ListSelectorTextItem.class); when(listSelectorItem.getCommand()).thenReturn(command); grid.onItemSelected(listSelectorItem); verify(command).execute(); } |
### Question:
DecisionTableGrid extends BaseExpressionGrid<DecisionTable, DecisionTableGridData, DecisionTableUIModelMapper> implements HasListSelectorControl,
HasHitPolicyControl { void addInputClause(final int index) { getExpression().get().ifPresent(dtable -> { final InputClause clause = new InputClause(); final CommandResult<CanvasViolation> result = sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new AddInputClauseCommand(dtable, clause, model, () -> makeInputClauseColumn(index, clause), index, uiModelMapper, () -> resize(BaseExpressionGrid.RESIZE_EXISTING), () -> resize(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM))); if (!CommandUtils.isError(result)) { selectHeaderCell(0, index, false, false); CellContextUtilities.editSelectedCell(this); } }); } DecisionTableGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final DecisionTableGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final HitPolicyPopoverView.Presenter hitPolicyEditor,
final ManagedInstance<ValueAndDataTypePopoverView.Presenter> headerEditors,
final ReadOnlyProvider readOnlyProvider); @Override DecisionTableUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override HitPolicy getHitPolicy(); @Override BuiltinAggregator getBuiltinAggregator(); @Override void setHitPolicy(final HitPolicy hitPolicy,
final Command onSuccess); @Override void setBuiltinAggregator(final BuiltinAggregator aggregator); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test @SuppressWarnings("unchecked") public void testAddInputClause() { setupGrid(makeHasNameForDecision(), 0); addInputClause(1); verifyCommandExecuteOperation(BaseExpressionGrid.RESIZE_EXISTING); verify(grid).selectHeaderCell(eq(0), eq(1), eq(false), eq(false)); verifyEditHeaderCell(InputClauseColumnHeaderMetaData.class, 0, 1); reset(gridPanel, gridLayer, grid, parentGridColumn); verify(sessionCommandManager).execute(eq(canvasHandler), addInputClauseCommandCaptor.capture()); addInputClauseCommandCaptor.getValue().undo(canvasHandler); verifyCommandUndoOperation(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM); }
@Test public void testMultipleInputClauseColumnHeaderEditorInstances() { final ValueAndDataTypePopoverView.Presenter headerEditor2 = mock(ValueAndDataTypePopoverView.Presenter.class); when(headerEditors.get()).thenReturn(headerEditor, headerEditor2); setupGrid(makeHasNameForDecision(), 0); addInputClause(2); reset(headerEditor2); final GridColumn uiColumn1 = grid.getModel().getColumns().get(1); assertInputClauseColumnHeaderEditor(uiColumn1, headerEditor); final GridColumn uiColumn2 = grid.getModel().getColumns().get(2); assertInputClauseColumnHeaderEditor(uiColumn2, headerEditor2); } |
### Question:
DecisionTableGrid extends BaseExpressionGrid<DecisionTable, DecisionTableGridData, DecisionTableUIModelMapper> implements HasListSelectorControl,
HasHitPolicyControl { void deleteInputClause(final int index) { getExpression().get().ifPresent(dtable -> { sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new DeleteInputClauseCommand(dtable, model, index, uiModelMapper, () -> resize(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM), () -> resize(BaseExpressionGrid.RESIZE_EXISTING))); }); } DecisionTableGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final DecisionTableGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final HitPolicyPopoverView.Presenter hitPolicyEditor,
final ManagedInstance<ValueAndDataTypePopoverView.Presenter> headerEditors,
final ReadOnlyProvider readOnlyProvider); @Override DecisionTableUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override HitPolicy getHitPolicy(); @Override BuiltinAggregator getBuiltinAggregator(); @Override void setHitPolicy(final HitPolicy hitPolicy,
final Command onSuccess); @Override void setBuiltinAggregator(final BuiltinAggregator aggregator); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test @SuppressWarnings("unchecked") public void testDeleteInputClause() { setupGrid(makeHasNameForDecision(), 0); grid.deleteInputClause(1); verify(sessionCommandManager).execute(eq(canvasHandler), deleteInputClauseCommandCaptor.capture()); final DeleteInputClauseCommand deleteInputClauseCommand = deleteInputClauseCommandCaptor.getValue(); deleteInputClauseCommand.execute(canvasHandler); verifyCommandExecuteOperation(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM); reset(gridPanel, gridLayer, grid, parentGridColumn); deleteInputClauseCommand.undo(canvasHandler); verifyCommandUndoOperation(BaseExpressionGrid.RESIZE_EXISTING); } |
### Question:
DecisionTableGrid extends BaseExpressionGrid<DecisionTable, DecisionTableGridData, DecisionTableUIModelMapper> implements HasListSelectorControl,
HasHitPolicyControl { void deleteOutputClause(final int index) { getExpression().get().ifPresent(dtable -> { sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new DeleteOutputClauseCommand(dtable, model, index, uiModelMapper, () -> resize(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM), () -> resize(BaseExpressionGrid.RESIZE_EXISTING))); }); } DecisionTableGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final DecisionTableGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final HitPolicyPopoverView.Presenter hitPolicyEditor,
final ManagedInstance<ValueAndDataTypePopoverView.Presenter> headerEditors,
final ReadOnlyProvider readOnlyProvider); @Override DecisionTableUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override HitPolicy getHitPolicy(); @Override BuiltinAggregator getBuiltinAggregator(); @Override void setHitPolicy(final HitPolicy hitPolicy,
final Command onSuccess); @Override void setBuiltinAggregator(final BuiltinAggregator aggregator); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testDeleteOutputClause() { setupGrid(makeHasNameForDecision(), 0); grid.deleteOutputClause(2); verify(sessionCommandManager).execute(eq(canvasHandler), deleteOutputClauseCommandCaptor.capture()); final DeleteOutputClauseCommand deleteOutputClauseCommand = deleteOutputClauseCommandCaptor.getValue(); deleteOutputClauseCommand.execute(canvasHandler); verifyCommandExecuteOperation(BaseExpressionGrid.RESIZE_EXISTING_MINIMUM); reset(gridPanel, gridLayer, grid, parentGridColumn); deleteOutputClauseCommand.undo(canvasHandler); verifyCommandUndoOperation(BaseExpressionGrid.RESIZE_EXISTING); } |
### Question:
DMNExternalLinksToExtensionElements { static DMNElement.ExtensionElements getOrCreateExtensionElements(final DRGElement target) { return target.getExtensionElements() == null ? new TDMNElement.TExtensionElements() : target.getExtensionElements(); } }### Answer:
@Test public void testGetOrCreateExtensionElements() { final DRGElement element = mock(DRGElement.class); final DMNElement.ExtensionElements result = getOrCreateExtensionElements(element); assertNotNull(result); final DMNElement.ExtensionElements existingElements = mock(DMNElement.ExtensionElements.class); when(element.getExtensionElements()).thenReturn(existingElements); final DMNElement.ExtensionElements actual = getOrCreateExtensionElements(element); assertEquals(actual, existingElements); } |
### Question:
DecisionTableGrid extends BaseExpressionGrid<DecisionTable, DecisionTableGridData, DecisionTableUIModelMapper> implements HasListSelectorControl,
HasHitPolicyControl { void addDecisionRule(final int index) { getExpression().get().ifPresent(dtable -> { final GridRow decisionTableRow = new LiteralExpressionGridRow(); final DecisionRule decisionRule = DecisionRuleFactory.makeDecisionRule(dtable); sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new AddDecisionRuleCommand(dtable, decisionRule, model, decisionTableRow, index, uiModelMapper, () -> resize(BaseExpressionGrid.RESIZE_EXISTING))); }); } DecisionTableGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final DecisionTableGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final HitPolicyPopoverView.Presenter hitPolicyEditor,
final ManagedInstance<ValueAndDataTypePopoverView.Presenter> headerEditors,
final ReadOnlyProvider readOnlyProvider); @Override DecisionTableUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override HitPolicy getHitPolicy(); @Override BuiltinAggregator getBuiltinAggregator(); @Override void setHitPolicy(final HitPolicy hitPolicy,
final Command onSuccess); @Override void setBuiltinAggregator(final BuiltinAggregator aggregator); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testAddDecisionRule() { setupGrid(makeHasNameForDecision(), 0); final DecisionTable dtable = grid.getExpression().get().get(); assertThat(dtable.getRule().size()).isEqualTo(1); assertThat(dtable.getRule().get(0).getInputEntry().size()).isEqualTo(1); assertThat(dtable.getRule().get(0).getOutputEntry().size()).isEqualTo(1); addDecisionRule(0); assertThat(dtable.getRule().size()).isEqualTo(2); assertThat(dtable.getRule().get(1).getInputEntry().size()).isEqualTo(1); assertThat(dtable.getRule().get(1).getOutputEntry().size()).isEqualTo(1); verifyCommandExecuteOperation(BaseExpressionGrid.RESIZE_EXISTING); } |
### Question:
DecisionTableGrid extends BaseExpressionGrid<DecisionTable, DecisionTableGridData, DecisionTableUIModelMapper> implements HasListSelectorControl,
HasHitPolicyControl { void deleteDecisionRule(final int index) { getExpression().get().ifPresent(dtable -> { sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new DeleteDecisionRuleCommand(dtable, model, index, () -> resize(BaseExpressionGrid.RESIZE_EXISTING))); }); } DecisionTableGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final DecisionTableGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final HitPolicyPopoverView.Presenter hitPolicyEditor,
final ManagedInstance<ValueAndDataTypePopoverView.Presenter> headerEditors,
final ReadOnlyProvider readOnlyProvider); @Override DecisionTableUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override HitPolicy getHitPolicy(); @Override BuiltinAggregator getBuiltinAggregator(); @Override void setHitPolicy(final HitPolicy hitPolicy,
final Command onSuccess); @Override void setBuiltinAggregator(final BuiltinAggregator aggregator); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testDeleteDecisionRule() { setupGrid(makeHasNameForDecision(), 0); grid.deleteDecisionRule(0); verify(sessionCommandManager).execute(eq(canvasHandler), deleteDecisionRuleCommandCaptor.capture()); final DeleteDecisionRuleCommand deleteDecisionRuleCommand = deleteDecisionRuleCommandCaptor.getValue(); deleteDecisionRuleCommand.execute(canvasHandler); verifyCommandExecuteOperation(BaseExpressionGrid.RESIZE_EXISTING); } |
### Question:
DecisionTableGrid extends BaseExpressionGrid<DecisionTable, DecisionTableGridData, DecisionTableUIModelMapper> implements HasListSelectorControl,
HasHitPolicyControl { @Override public void setBuiltinAggregator(final BuiltinAggregator aggregator) { getExpression().get().ifPresent(dtable -> { sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new SetBuiltinAggregatorCommand(dtable, aggregator, gridLayer::batch)); }); } DecisionTableGrid(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final DMNGridPanel gridPanel,
final DMNGridLayer gridLayer,
final DecisionTableGridData gridData,
final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final CellEditorControlsView.Presenter cellEditorControls,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final boolean isOnlyVisualChangeAllowed,
final int nesting,
final HitPolicyPopoverView.Presenter hitPolicyEditor,
final ManagedInstance<ValueAndDataTypePopoverView.Presenter> headerEditors,
final ReadOnlyProvider readOnlyProvider); @Override DecisionTableUIModelMapper makeUiModelMapper(); @Override void initialiseUiColumns(); @Override void initialiseUiRows(); @Override void initialiseUiCells(); @Override @SuppressWarnings("unused") List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override HitPolicy getHitPolicy(); @Override BuiltinAggregator getBuiltinAggregator(); @Override void setHitPolicy(final HitPolicy hitPolicy,
final Command onSuccess); @Override void setBuiltinAggregator(final BuiltinAggregator aggregator); @Override void doAfterSelectionChange(final int uiRowIndex,
final int uiColumnIndex); @Override void doAfterHeaderSelectionChange(final int uiHeaderRowIndex,
final int uiHeaderColumnIndex); }### Answer:
@Test public void testSetBuiltInAggregator() { final BuiltinAggregator aggregator = BuiltinAggregator.SUM; setupGrid(makeHasNameForDecision(), 0); grid.setBuiltinAggregator(aggregator); verify(sessionCommandManager).execute(eq(canvasHandler), setBuiltInAggregatorCommandCaptor.capture()); final SetBuiltinAggregatorCommand setBuiltinAggregatorCommand = setBuiltInAggregatorCommandCaptor.getValue(); setBuiltinAggregatorCommand.execute(canvasHandler); verify(gridLayer).batch(); } |
### Question:
ItemDefinitionPropertyConverter { public static ItemDefinition wbFromDMN(final org.kie.dmn.model.api.ItemDefinition dmn) { if (dmn == null) { return null; } final Id id = new Id(dmn.getId()); final Name name = new Name(dmn.getName()); final Description description = wbDescriptionFromDMN(dmn); final QName typeRef = wbTypeRefFromDMN(dmn); final String typeLanguage = dmn.getTypeLanguage(); final boolean isCollection = dmn.isIsCollection(); final ItemDefinition wb = new ItemDefinition(id, description, name, typeRef, null, null, typeLanguage, isCollection, false); setUnaryTests(wb, dmn); setItemComponent(wb, dmn); return wb; } static ItemDefinition wbFromDMN(final org.kie.dmn.model.api.ItemDefinition dmn); static org.kie.dmn.model.api.ItemDefinition dmnFromWB(final ItemDefinition wb); }### Answer:
@Test public void testWbFromDMNWhenDMNIsNull() { assertNull(wbFromDMN(null)); }
@Test public void testWbFromDMNWhenDMNIsNotNull() { final org.kie.dmn.model.api.ItemDefinition dmn = mock(org.kie.dmn.model.api.ItemDefinition.class); final String id = "id"; final String name = "name"; final Id expectedId = new Id(id); final Name expectedName = new Name(name); final String expectedTypeLanguage = "typeLanguage"; final boolean expectedIsCollection = true; final String description = "description"; final boolean expectedAllowOnlyVisualChange = false; final String qNameNamespaceURI = "qName namespaceURI"; final String qNameLocalPart = "qName local part"; final String qNamePrefix = "qName prefix"; final Description expectedDescription = new Description(description); final javax.xml.namespace.QName expectedTypeRef = new javax.xml.namespace.QName(qNameNamespaceURI, qNameLocalPart, qNamePrefix); when(dmn.getId()).thenReturn(id); when(dmn.getName()).thenReturn(name); when(dmn.getTypeLanguage()).thenReturn(expectedTypeLanguage); when(dmn.isIsCollection()).thenReturn(expectedIsCollection); when(dmn.getDescription()).thenReturn(description); when(dmn.getTypeRef()).thenReturn(expectedTypeRef); final ItemDefinition actualItemDefinition = wbFromDMN(dmn); final Id actualId = actualItemDefinition.getId(); final Name actualName = actualItemDefinition.getName(); final String actualTypeLanguage = actualItemDefinition.getTypeLanguage(); final boolean actualIsCollection = actualItemDefinition.isIsCollection(); final Description actualDescription = actualItemDefinition.getDescription(); final QName actualTypeRef = actualItemDefinition.getTypeRef(); final boolean actualAllowOnlyVisualChange = actualItemDefinition.isAllowOnlyVisualChange(); assertEquals(expectedId, actualId); assertEquals(expectedName, actualName); assertEquals(expectedTypeLanguage, actualTypeLanguage); assertEquals(expectedIsCollection, actualIsCollection); assertEquals(expectedDescription, actualDescription); assertEquals(expectedAllowOnlyVisualChange, actualAllowOnlyVisualChange); assertEquals(expectedTypeRef.getLocalPart(), actualTypeRef.getLocalPart()); assertEquals(expectedTypeRef.getPrefix(), actualTypeRef.getPrefix()); assertEquals(expectedTypeRef.getNamespaceURI(), actualTypeRef.getNamespaceURI()); } |
### Question:
DecisionTableUIModelMapper extends BaseUIModelMapper<DecisionTable> { @Override public void toDMNModel(final int rowIndex, final int columnIndex, final Supplier<Optional<GridCellValue<?>>> cell) { dmnModel.get().ifPresent(dtable -> { final DecisionRule rule = dtable.getRule().get(rowIndex); final DecisionTableSection section = DecisionTableUIModelMapperHelper.getSection(dtable, columnIndex); switch (section) { case ROW_INDEX: break; case INPUT_CLAUSES: final int iei = DecisionTableUIModelMapperHelper.getInputEntryIndex(dtable, columnIndex); rule.getInputEntry().get(iei).getText().setValue(cell.get().orElse(new BaseGridCellValue<>("")).getValue().toString()); break; case OUTPUT_CLAUSES: final int oei = DecisionTableUIModelMapperHelper.getOutputEntryIndex(dtable, columnIndex); rule.getOutputEntry().get(oei).getText().setValue(cell.get().orElse(new BaseGridCellValue<>("")).getValue().toString()); break; case ANNOTATION_CLAUSES: final int annotationIndex = DecisionTableUIModelMapperHelper.getAnnotationEntryIndex(dtable, columnIndex); rule.getAnnotationEntry().get(annotationIndex).getText().setValue(cell.get().orElse(new BaseGridCellValue<>("")).getValue().toString()); break; } }); } DecisionTableUIModelMapper(final Supplier<GridData> uiModel,
final Supplier<Optional<DecisionTable>> dmnModel,
final ListSelectorView.Presenter listSelector,
final double lineHeight); @Override void fromDMNModel(final int rowIndex,
final int columnIndex); @Override void toDMNModel(final int rowIndex,
final int columnIndex,
final Supplier<Optional<GridCellValue<?>>> cell); }### Answer:
@Test public void testToDMNModelInputClause() { mapper.toDMNModel(0, 1, Optional::empty); mapper.toDMNModel(1, 1, () -> Optional.of(new BaseGridCellValue<>("value"))); assertEquals("", dtable.getRule().get(0).getInputEntry().get(0).getText().getValue()); assertEquals("value", dtable.getRule().get(1).getInputEntry().get(0).getText().getValue()); }
@Test public void testToDMNModelOutputClause() { mapper.toDMNModel(0, 2, Optional::empty); mapper.toDMNModel(1, 2, () -> Optional.of(new BaseGridCellValue<>("value"))); assertEquals("", dtable.getRule().get(0).getOutputEntry().get(0).getText().getValue()); assertEquals("value", dtable.getRule().get(1).getOutputEntry().get(0).getText().getValue()); }
@Test public void testToDMNModelRuleAnnotationClause() { mapper.toDMNModel(0, 3, Optional::empty); mapper.toDMNModel(1, 3, () -> Optional.of(new BaseGridCellValue<>("value"))); assertEquals("", dtable.getRule().get(0).getAnnotationEntry().get(0).getText().getValue()); assertEquals("value", dtable.getRule().get(1).getAnnotationEntry().get(0).getText().getValue()); } |
### Question:
DecisionTableGridData extends DelegatingGridData { @Override public void moveRowTo(final int index, final GridRow row) { moveRowsTo(index, Collections.singletonList(row)); } DecisionTableGridData(final DMNGridData delegate,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Supplier<Optional<DecisionTable>> expression,
final Command canvasOperation); @Override void moveRowTo(final int index,
final GridRow row); @Override void moveRowsTo(final int index,
final List<GridRow> rows); @Override void moveColumnTo(final int index,
final GridColumn<?> column); @Override void moveColumnsTo(final int index,
final List<GridColumn<?>> columns); }### Answer:
@Test public void testMoveRowTo() { uiModel.moveRowTo(0, gridRow); verify(sessionCommandManager).execute(eq(canvasHandler), any(MoveRowsCommand.class)); } |
### Question:
DecisionTableGridData extends DelegatingGridData { @Override public void moveRowsTo(final int index, final List<GridRow> rows) { expression.get().ifPresent(dtable -> sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new MoveRowsCommand(dtable, delegate, index, rows, canvasOperation))); } DecisionTableGridData(final DMNGridData delegate,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Supplier<Optional<DecisionTable>> expression,
final Command canvasOperation); @Override void moveRowTo(final int index,
final GridRow row); @Override void moveRowsTo(final int index,
final List<GridRow> rows); @Override void moveColumnTo(final int index,
final GridColumn<?> column); @Override void moveColumnsTo(final int index,
final List<GridColumn<?>> columns); }### Answer:
@Test public void testMoveRowsTo() { uiModel.moveRowsTo(0, Collections.singletonList(gridRow)); verify(sessionCommandManager).execute(eq(canvasHandler), any(MoveRowsCommand.class)); } |
### Question:
DecisionTableGridData extends DelegatingGridData { @Override public void moveColumnTo(final int index, final GridColumn<?> column) { moveColumnsTo(index, new Lists.Builder<GridColumn<?>>() .add(column) .build() ); } DecisionTableGridData(final DMNGridData delegate,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Supplier<Optional<DecisionTable>> expression,
final Command canvasOperation); @Override void moveRowTo(final int index,
final GridRow row); @Override void moveRowsTo(final int index,
final List<GridRow> rows); @Override void moveColumnTo(final int index,
final GridColumn<?> column); @Override void moveColumnsTo(final int index,
final List<GridColumn<?>> columns); }### Answer:
@Test public void testMoveColumnTo() { uiModel.moveColumnTo(0, gridColumn); verify(sessionCommandManager).execute(eq(canvasHandler), any(MoveColumnsCommand.class)); } |
### Question:
DecisionTableGridData extends DelegatingGridData { @Override public void moveColumnsTo(final int index, final List<GridColumn<?>> columns) { expression.get().ifPresent(dtable -> sessionCommandManager.execute((AbstractCanvasHandler) sessionManager.getCurrentSession().getCanvasHandler(), new MoveColumnsCommand(dtable, delegate, index, columns, canvasOperation))); } DecisionTableGridData(final DMNGridData delegate,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Supplier<Optional<DecisionTable>> expression,
final Command canvasOperation); @Override void moveRowTo(final int index,
final GridRow row); @Override void moveRowsTo(final int index,
final List<GridRow> rows); @Override void moveColumnTo(final int index,
final GridColumn<?> column); @Override void moveColumnsTo(final int index,
final List<GridColumn<?>> columns); }### Answer:
@Test public void testMoveColumnsTo() { uiModel.moveColumnsTo(0, Collections.singletonList(gridColumn)); verify(sessionCommandManager).execute(eq(canvasHandler), any(MoveColumnsCommand.class)); } |
### Question:
DecisionTableEditorDefinition extends BaseEditorDefinition<DecisionTable, DecisionTableGridData> { @Override public ExpressionType getType() { return ExpressionType.DECISION_TABLE; } DecisionTableEditorDefinition(); @Inject DecisionTableEditorDefinition(final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final HitPolicyPopoverView.Presenter hitPolicyEditor,
final ManagedInstance<ValueAndDataTypePopoverView.Presenter> headerEditors,
final DecisionTableEditorDefinitionEnricher enricher,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override ExpressionType getType(); @Override String getName(); @Override Optional<DecisionTable> getModelClass(); @Override void enrich(final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<DecisionTable> expression); @Override @SuppressWarnings("unused") Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final boolean isOnlyVisualChangeAllowed,
final int nesting); }### Answer:
@Test public void testType() { assertThat(definition.getType()).isEqualTo(ExpressionType.DECISION_TABLE); } |
### Question:
ItemDefinitionPropertyConverter { static void setItemComponent(final ItemDefinition wb, final org.kie.dmn.model.api.ItemDefinition dmn) { dmn.getItemComponent().forEach(dmnChild -> { wb.getItemComponent().add(wbChildFromDMN(wb, dmnChild)); }); } static ItemDefinition wbFromDMN(final org.kie.dmn.model.api.ItemDefinition dmn); static org.kie.dmn.model.api.ItemDefinition dmnFromWB(final ItemDefinition wb); }### Answer:
@Test public void testSetItemComponent() { final String id = "id"; final String name = "name"; final String typeLanguage = "typeLanguage"; final boolean isCollection = true; final boolean isOnlyVisualChanges = false; final String description = "description"; final ItemDefinition expectedWbChild = new ItemDefinition(new Id(id), new Description(description), new Name(name), null, null, null, typeLanguage, isCollection, isOnlyVisualChanges); final ItemDefinition wb = new ItemDefinition(); final org.kie.dmn.model.api.ItemDefinition dmn = mock(org.kie.dmn.model.api.ItemDefinition.class); final org.kie.dmn.model.api.ItemDefinition dmnChild = mock(org.kie.dmn.model.api.ItemDefinition.class); when(dmnChild.getId()).thenReturn(id); when(dmnChild.getName()).thenReturn(name); when(dmnChild.getTypeLanguage()).thenReturn(typeLanguage); when(dmnChild.isIsCollection()).thenReturn(isCollection); when(dmnChild.getDescription()).thenReturn(description); when(dmnChild.getTypeRef()).thenReturn(null); when(dmn.getItemComponent()).thenReturn(singletonList(dmnChild)); setItemComponent(wb, dmn); final List<ItemDefinition> expectedItemDefinitions = singletonList(expectedWbChild); final List<ItemDefinition> actualItemDefinitions = wb.getItemComponent(); assertEquals(expectedItemDefinitions, actualItemDefinitions); assertEquals(wb, actualItemDefinitions.get(0).getParent()); } |
### Question:
DecisionTableEditorDefinition extends BaseEditorDefinition<DecisionTable, DecisionTableGridData> { @Override public String getName() { return translationService.format(DMNEditorConstants.ExpressionEditor_DecisionTableExpressionType); } DecisionTableEditorDefinition(); @Inject DecisionTableEditorDefinition(final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final HitPolicyPopoverView.Presenter hitPolicyEditor,
final ManagedInstance<ValueAndDataTypePopoverView.Presenter> headerEditors,
final DecisionTableEditorDefinitionEnricher enricher,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override ExpressionType getType(); @Override String getName(); @Override Optional<DecisionTable> getModelClass(); @Override void enrich(final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<DecisionTable> expression); @Override @SuppressWarnings("unused") Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final boolean isOnlyVisualChangeAllowed,
final int nesting); }### Answer:
@Test public void testName() { assertThat(definition.getName()).isEqualTo(DMNEditorConstants.ExpressionEditor_DecisionTableExpressionType); } |
### Question:
DecisionTableEditorDefinition extends BaseEditorDefinition<DecisionTable, DecisionTableGridData> { @Override public Optional<DecisionTable> getModelClass() { return Optional.of(new DecisionTable()); } DecisionTableEditorDefinition(); @Inject DecisionTableEditorDefinition(final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final HitPolicyPopoverView.Presenter hitPolicyEditor,
final ManagedInstance<ValueAndDataTypePopoverView.Presenter> headerEditors,
final DecisionTableEditorDefinitionEnricher enricher,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override ExpressionType getType(); @Override String getName(); @Override Optional<DecisionTable> getModelClass(); @Override void enrich(final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<DecisionTable> expression); @Override @SuppressWarnings("unused") Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final boolean isOnlyVisualChangeAllowed,
final int nesting); }### Answer:
@Test public void testModelDefinition() { final Optional<DecisionTable> oModel = definition.getModelClass(); assertThat(oModel).isPresent(); } |
### Question:
DecisionTableEditorDefinition extends BaseEditorDefinition<DecisionTable, DecisionTableGridData> { @Override @SuppressWarnings("unused") public Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent, final Optional<String> nodeUUID, final HasExpression hasExpression, final Optional<HasName> hasName, final boolean isOnlyVisualChangeAllowed, final int nesting) { return Optional.of(new DecisionTableGrid(parent, nodeUUID, hasExpression, hasName, getGridPanel(), getGridLayer(), makeGridData(() -> Optional.ofNullable((DecisionTable) hasExpression.getExpression())), definitionUtils, sessionManager, sessionCommandManager, canvasCommandFactory, editorSelectedEvent, refreshFormPropertiesEvent, domainObjectSelectionEvent, getCellEditorControls(), listSelector, translationService, isOnlyVisualChangeAllowed, nesting, hitPolicyEditor, headerEditors, readOnlyProvider)); } DecisionTableEditorDefinition(); @Inject DecisionTableEditorDefinition(final DefinitionUtils definitionUtils,
final SessionManager sessionManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final @DMNEditor DefaultCanvasCommandFactory canvasCommandFactory,
final Event<ExpressionEditorChanged> editorSelectedEvent,
final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final Event<DomainObjectSelectionEvent> domainObjectSelectionEvent,
final ListSelectorView.Presenter listSelector,
final TranslationService translationService,
final HitPolicyPopoverView.Presenter hitPolicyEditor,
final ManagedInstance<ValueAndDataTypePopoverView.Presenter> headerEditors,
final DecisionTableEditorDefinitionEnricher enricher,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @Override ExpressionType getType(); @Override String getName(); @Override Optional<DecisionTable> getModelClass(); @Override void enrich(final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<DecisionTable> expression); @Override @SuppressWarnings("unused") Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> getEditor(final GridCellTuple parent,
final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<HasName> hasName,
final boolean isOnlyVisualChangeAllowed,
final int nesting); }### Answer:
@Test public void testEditor() { final Optional<BaseExpressionGrid<? extends Expression, ? extends GridData, ? extends BaseUIModelMapper>> oEditor = definition.getEditor(parent, Optional.empty(), decision, hasName, false, 0); assertThat(oEditor).isPresent(); final GridWidget editor = oEditor.get(); assertThat(editor).isInstanceOf(DecisionTableGrid.class); } |
### Question:
InputClauseColumn extends DMNSimpleGridColumn<DecisionTableGrid, String> implements HasSingletonDOMElementResource { @Override public void destroyResources() { super.destroyResources(); factory.destroyResources(); } InputClauseColumn(final HeaderMetaData headerMetaData,
final TextAreaSingletonDOMElementFactory factory,
final double width,
final DecisionTableGrid gridWidget); InputClauseColumn(final List<HeaderMetaData> headerMetaData,
final TextAreaSingletonDOMElementFactory factory,
final double width,
final DecisionTableGrid gridWidget); @Override void edit(final GridCell<String> cell,
final GridBodyCellRenderContext context,
final Consumer<GridCellValue<String>> callback); @Override void flush(); @Override void destroyResources(); @Override void setWidth(final double width); }### Answer:
@Test public void checkHeaderDOMElementsAreDestroyed() { final MockHasDOMElementResourcesHeaderMetaData mockHeaderMetaData = mock(MockHasDOMElementResourcesHeaderMetaData.class); column.getHeaderMetaData().add(mockHeaderMetaData); column.destroyResources(); verify(mockHeaderMetaData).destroyResources(); } |
### Question:
ItemDefinitionPropertyConverter { static void setUnaryTests(final ItemDefinition wb, final org.kie.dmn.model.api.ItemDefinition dmn) { final org.kie.dmn.model.api.UnaryTests dmnAllowedValues = dmn.getAllowedValues(); final Optional<UnaryTests> wbUnaryTests = ofNullable(UnaryTestsPropertyConverter.wbFromDMN(dmnAllowedValues)); wbUnaryTests.ifPresent(unaryTests -> { wb.setAllowedValues(unaryTests); unaryTests.setParent(wb); }); } static ItemDefinition wbFromDMN(final org.kie.dmn.model.api.ItemDefinition dmn); static org.kie.dmn.model.api.ItemDefinition dmnFromWB(final ItemDefinition wb); }### Answer:
@Test public void testSetUnaryTestsWhenUnaryTestsIsNotNull() { final ItemDefinition wb = mock(ItemDefinition.class); final ArgumentCaptor<UnaryTests> argument = ArgumentCaptor.forClass(UnaryTests.class); final org.kie.dmn.model.api.ItemDefinition dmn = mock(org.kie.dmn.model.api.ItemDefinition.class); final org.kie.dmn.model.api.UnaryTests dmnAllowedValues = mock(org.kie.dmn.model.api.UnaryTests.class); when(dmn.getAllowedValues()).thenReturn(dmnAllowedValues); setUnaryTests(wb, dmn); verify(wb).setAllowedValues(argument.capture()); assertEquals(wb, argument.getValue().getParent()); }
@Test public void testSetUnaryTestsWhenUnaryTestsIsNull() { final ItemDefinition wb = mock(ItemDefinition.class); final UnaryTests wbAllowedValues = mock(UnaryTests.class); final org.kie.dmn.model.api.ItemDefinition dmn = mock(org.kie.dmn.model.api.ItemDefinition.class); final org.kie.dmn.model.api.UnaryTests dmnAllowedValues = null; when(dmn.getAllowedValues()).thenReturn(dmnAllowedValues); setUnaryTests(wb, dmn); verify(wb, never()).setAllowedValues(wbAllowedValues); verify(wbAllowedValues, never()).setParent(wb); } |
### Question:
DMNImportTypesHelperImpl implements DMNImportTypesHelper { @Override public boolean isDMN(final Path path) { return matchesExtension(path, DMNImportTypes.DMN); } @Override boolean isDMN(final Path path); @Override boolean isPMML(final Path path); @Override boolean isJava(final Path path); }### Answer:
@Test public void testIsDMN() { assertThat(helper.isDMN(dmnPath)).isTrue(); assertThat(helper.isDMN(pmmlPath)).isFalse(); assertThat(helper.isDMN(javaPath)).isFalse(); } |
### Question:
DecisionTableEditorDefinitionEnricher implements ExpressionEditorModelEnricher<DecisionTable> { private void addInputClauseRequirement(final QName typeRef, final Definitions definitions, final List<ClauseRequirement> inputClauseRequirements, final String text) { if (isBuiltInType(typeRef.getLocalPart())) { inputClauseRequirements.add(new ClauseRequirement(text, typeRef)); return; } definitions.getItemDefinition() .stream() .filter(typeRefIsCustom(typeRef)) .findFirst() .ifPresent(itemDefinition -> addInputClauseRequirement(itemDefinition, inputClauseRequirements, text)); } DecisionTableEditorDefinitionEnricher(); @Inject DecisionTableEditorDefinitionEnricher(final SessionManager sessionManager,
final DMNGraphUtils dmnGraphUtils,
final ItemDefinitionUtils itemDefinitionUtils); @Override void enrich(final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<DecisionTable> expression); }### Answer:
@Test public void testAddInputClauseRequirement() { final List<DecisionTableEditorDefinitionEnricher.ClauseRequirement> inputClauseRequirements = new ArrayList<>(); final String inputData = "InputData"; final DecisionTableEditorDefinitionEnricher enricher = new DecisionTableEditorDefinitionEnricher(null, null, itemDefinitionUtils); final ItemDefinition tPerson = mockTPersonStructure(); enricher.addInputClauseRequirement(tPerson, inputClauseRequirements, inputData); assertEquals(2, inputClauseRequirements.size()); final DecisionTableEditorDefinitionEnricher.ClauseRequirement inputClause1 = inputClauseRequirements.get(0); final DecisionTableEditorDefinitionEnricher.ClauseRequirement inputClause2 = inputClauseRequirements.get(1); assertEquals("InputData.name", inputClause1.text); assertEquals(STRING.getName(), inputClause1.typeRef.getLocalPart()); assertEquals("InputData.age", inputClause2.text); assertEquals(NUMBER.getName(), inputClause2.typeRef.getLocalPart()); }
@Test public void testAddInputClauseRequirementWhenDataTypeIsStructureAndDontHaveFields() { final ItemDefinition tPerson = mock(ItemDefinition.class); final String inputData = "InputData"; final List<DecisionTableEditorDefinitionEnricher.ClauseRequirement> inputClauseRequirements = new ArrayList<>(); final ItemDefinitionUtils itemDefinitionUtils = new ItemDefinitionUtils(mock(DMNGraphUtils.class)); final DecisionTableEditorDefinitionEnricher enricher = new DecisionTableEditorDefinitionEnricher(null, null, itemDefinitionUtils); when(tPerson.getName()).thenReturn(new Name(TYPE_PERSON)); when(tPerson.getTypeRef()).thenReturn(null); when(tPerson.getItemComponent()).thenReturn(emptyList()); enricher.addInputClauseRequirement(tPerson, inputClauseRequirements, inputData); assertEquals(1, inputClauseRequirements.size()); assertEquals("InputData", inputClauseRequirements.get(0).text); assertEquals(TYPE_PERSON, inputClauseRequirements.get(0).typeRef.getLocalPart()); } |
### Question:
DecisionTableEditorDefinitionEnricher implements ExpressionEditorModelEnricher<DecisionTable> { String computeClauseName(final ItemDefinition itemComponent) { final String originalName = itemComponent.getName().getValue(); String nameWithoutModelRef = originalName; if (itemComponent.isImported()) { final int positionOfLastDot = originalName.lastIndexOf(DOT_CHAR) + 1; if (positionOfLastDot > 0 && positionOfLastDot != originalName.length()) { nameWithoutModelRef = originalName.substring(positionOfLastDot); } } return nameWithoutModelRef; } DecisionTableEditorDefinitionEnricher(); @Inject DecisionTableEditorDefinitionEnricher(final SessionManager sessionManager,
final DMNGraphUtils dmnGraphUtils,
final ItemDefinitionUtils itemDefinitionUtils); @Override void enrich(final Optional<String> nodeUUID,
final HasExpression hasExpression,
final Optional<DecisionTable> expression); }### Answer:
@Test public void testComputingClauseNameWithoutModelRef() { final ItemDefinition itemComponent = new ItemDefinition(); itemComponent.setName(new Name("model.age")); itemComponent.setAllowOnlyVisualChange(true); assertEquals("age", new DecisionTableEditorDefinitionEnricher(null, null, null) .computeClauseName(itemComponent)); }
@Test public void testComputingClauseNameWithoutModelRefWhenModelRefHasMultipleLevels() { final ItemDefinition itemComponent = new ItemDefinition(); itemComponent.setName(new Name("a.b.c.age")); itemComponent.setAllowOnlyVisualChange(true); assertEquals("age", new DecisionTableEditorDefinitionEnricher(null, null, null) .computeClauseName(itemComponent)); }
@Test public void testComputingClauseNameWithoutModelRefWhenModelRefAlreadyMissing() { final ItemDefinition itemComponent = new ItemDefinition(); itemComponent.setName(new Name("age")); itemComponent.setAllowOnlyVisualChange(true); assertEquals("age", new DecisionTableEditorDefinitionEnricher(null, null, null) .computeClauseName(itemComponent)); }
@Test public void testComputingClauseNameWithoutModelRefWhenLocalPartEndsWithDot() { final ItemDefinition itemComponent = new ItemDefinition(); itemComponent.setName(new Name("age.")); itemComponent.setAllowOnlyVisualChange(true); assertEquals("age.", new DecisionTableEditorDefinitionEnricher(null, null, null) .computeClauseName(itemComponent)); } |
### Question:
DecisionTableDefaultValueUtilities { public static String getNewInputClauseName(final DecisionTable dtable) { return INPUT_CLAUSE_PREFIX + getMaxUnusedInputClauseIndex(dtable); } static String getNewInputClauseName(final DecisionTable dtable); static String getNewOutputClauseName(final DecisionTable dtable); static String getNewRuleAnnotationClauseName(final DecisionTable decisionTable); static final String INPUT_CLAUSE_PREFIX; static final String INPUT_CLAUSE_UNARY_TEST_TEXT; static final String OUTPUT_CLAUSE_PREFIX; static final String OUTPUT_CLAUSE_EXPRESSION_TEXT; static final String RULE_DESCRIPTION; static final String RULE_ANNOTATION_CLAUSE_PREFIX; static final String RULE_ANNOTATION_CLAUSE_EXPRESSION_TEXT; }### Answer:
@Test public void testGetNewInputClauseName() { final InputClause inputClause1 = new InputClause() {{ setInputExpression(new InputClauseLiteralExpression()); }}; dtable.getInput().add(inputClause1); inputClause1.getInputExpression().getText().setValue(DecisionTableDefaultValueUtilities.getNewInputClauseName(dtable)); assertThat(inputClause1.getInputExpression().getText().getValue()).isEqualTo(DecisionTableDefaultValueUtilities.INPUT_CLAUSE_PREFIX + "1"); final InputClause inputClause2 = new InputClause() {{ setInputExpression(new InputClauseLiteralExpression()); }}; dtable.getInput().add(inputClause2); inputClause2.getInputExpression().getText().setValue(DecisionTableDefaultValueUtilities.getNewInputClauseName(dtable)); assertThat(inputClause2.getInputExpression().getText().getValue()).isEqualTo(DecisionTableDefaultValueUtilities.INPUT_CLAUSE_PREFIX + "2"); }
@Test public void testGetNewInputClauseNameWithExistingInputClauses() { final InputClause inputClause1 = new InputClause() {{ setInputExpression(new InputClauseLiteralExpression()); }}; dtable.getInput().add(inputClause1); inputClause1.getInputExpression().getText().setValue("input"); final InputClause inputClause2 = new InputClause() {{ setInputExpression(new InputClauseLiteralExpression()); }}; dtable.getInput().add(inputClause2); inputClause2.getInputExpression().getText().setValue(DecisionTableDefaultValueUtilities.getNewInputClauseName(dtable)); assertThat(inputClause2.getInputExpression().getText().getValue()).isEqualTo(DecisionTableDefaultValueUtilities.INPUT_CLAUSE_PREFIX + "1"); }
@Test public void testGetNewInputClauseNameWithDeletion() { final InputClause inputClause1 = new InputClause() {{ setInputExpression(new InputClauseLiteralExpression()); }}; dtable.getInput().add(inputClause1); inputClause1.getInputExpression().getText().setValue(DecisionTableDefaultValueUtilities.getNewInputClauseName(dtable)); assertThat(inputClause1.getInputExpression().getText().getValue()).isEqualTo(DecisionTableDefaultValueUtilities.INPUT_CLAUSE_PREFIX + "1"); final InputClause inputClause2 = new InputClause() {{ setInputExpression(new InputClauseLiteralExpression()); }}; dtable.getInput().add(inputClause2); inputClause2.getInputExpression().getText().setValue(DecisionTableDefaultValueUtilities.getNewInputClauseName(dtable)); assertThat(inputClause2.getInputExpression().getText().getValue()).isEqualTo(DecisionTableDefaultValueUtilities.INPUT_CLAUSE_PREFIX + "2"); dtable.getInput().remove(inputClause1); final InputClause inputClause3 = new InputClause() {{ setInputExpression(new InputClauseLiteralExpression()); }}; dtable.getInput().add(inputClause3); inputClause3.getInputExpression().getText().setValue(DecisionTableDefaultValueUtilities.getNewInputClauseName(dtable)); assertThat(inputClause3.getInputExpression().getText().getValue()).isEqualTo(DecisionTableDefaultValueUtilities.INPUT_CLAUSE_PREFIX + "3"); } |
### Question:
ItemDefinitionPropertyConverter { static Description wbDescriptionFromDMN(final org.kie.dmn.model.api.ItemDefinition dmn) { return DescriptionPropertyConverter.wbFromDMN(dmn.getDescription()); } static ItemDefinition wbFromDMN(final org.kie.dmn.model.api.ItemDefinition dmn); static org.kie.dmn.model.api.ItemDefinition dmnFromWB(final ItemDefinition wb); }### Answer:
@Test public void testWbDescriptionFromDMN() { final String description = "description"; final Description expectedDescription = new Description(description); final org.kie.dmn.model.api.ItemDefinition dmn = mock(org.kie.dmn.model.api.ItemDefinition.class); when(dmn.getDescription()).thenReturn(description); final Description actualDescription = wbDescriptionFromDMN(dmn); assertEquals(expectedDescription, actualDescription); } |
### Question:
DecisionTableDefaultValueUtilities { public static String getNewOutputClauseName(final DecisionTable dtable) { return OUTPUT_CLAUSE_PREFIX + getMaxUnusedOutputClauseIndex(dtable); } static String getNewInputClauseName(final DecisionTable dtable); static String getNewOutputClauseName(final DecisionTable dtable); static String getNewRuleAnnotationClauseName(final DecisionTable decisionTable); static final String INPUT_CLAUSE_PREFIX; static final String INPUT_CLAUSE_UNARY_TEST_TEXT; static final String OUTPUT_CLAUSE_PREFIX; static final String OUTPUT_CLAUSE_EXPRESSION_TEXT; static final String RULE_DESCRIPTION; static final String RULE_ANNOTATION_CLAUSE_PREFIX; static final String RULE_ANNOTATION_CLAUSE_EXPRESSION_TEXT; }### Answer:
@Test public void testGetNewOutputClauseName() { final OutputClause outputClause1 = new OutputClause(); dtable.getOutput().add(outputClause1); outputClause1.setName(DecisionTableDefaultValueUtilities.getNewOutputClauseName(dtable)); assertThat(outputClause1.getName()).isEqualTo(DecisionTableDefaultValueUtilities.OUTPUT_CLAUSE_PREFIX + "1"); final OutputClause outputClause2 = new OutputClause(); dtable.getOutput().add(outputClause2); outputClause2.setName(DecisionTableDefaultValueUtilities.getNewOutputClauseName(dtable)); assertThat(outputClause2.getName()).isEqualTo(DecisionTableDefaultValueUtilities.OUTPUT_CLAUSE_PREFIX + "2"); }
@Test public void testGetNewOutputClauseNameWithExistingOutputClauses() { final OutputClause outputClause1 = new OutputClause(); dtable.getOutput().add(outputClause1); outputClause1.setName("output"); final OutputClause outputClause2 = new OutputClause(); dtable.getOutput().add(outputClause2); outputClause2.setName(DecisionTableDefaultValueUtilities.getNewOutputClauseName(dtable)); assertThat(outputClause2.getName()).isEqualTo(DecisionTableDefaultValueUtilities.OUTPUT_CLAUSE_PREFIX + "1"); }
@Test public void testGetNewOutputClauseNameWithDeletion() { final OutputClause outputClause1 = new OutputClause(); dtable.getOutput().add(outputClause1); outputClause1.setName(DecisionTableDefaultValueUtilities.getNewOutputClauseName(dtable)); assertThat(outputClause1.getName()).isEqualTo(DecisionTableDefaultValueUtilities.OUTPUT_CLAUSE_PREFIX + "1"); final OutputClause outputClause2 = new OutputClause(); dtable.getOutput().add(outputClause2); outputClause2.setName(DecisionTableDefaultValueUtilities.getNewOutputClauseName(dtable)); assertThat(outputClause2.getName()).isEqualTo(DecisionTableDefaultValueUtilities.OUTPUT_CLAUSE_PREFIX + "2"); dtable.getOutput().remove(outputClause1); final OutputClause outputClause3 = new OutputClause(); dtable.getOutput().add(outputClause3); outputClause3.setName(DecisionTableDefaultValueUtilities.getNewOutputClauseName(dtable)); assertThat(outputClause3.getName()).isEqualTo(DecisionTableDefaultValueUtilities.OUTPUT_CLAUSE_PREFIX + "3"); } |
### Question:
DecisionTableDefaultValueUtilities { public static String getNewRuleAnnotationClauseName(final DecisionTable decisionTable) { return RULE_ANNOTATION_CLAUSE_PREFIX + getMaxUnusedRuleAnnotationClauseIndex(decisionTable); } static String getNewInputClauseName(final DecisionTable dtable); static String getNewOutputClauseName(final DecisionTable dtable); static String getNewRuleAnnotationClauseName(final DecisionTable decisionTable); static final String INPUT_CLAUSE_PREFIX; static final String INPUT_CLAUSE_UNARY_TEST_TEXT; static final String OUTPUT_CLAUSE_PREFIX; static final String OUTPUT_CLAUSE_EXPRESSION_TEXT; static final String RULE_DESCRIPTION; static final String RULE_ANNOTATION_CLAUSE_PREFIX; static final String RULE_ANNOTATION_CLAUSE_EXPRESSION_TEXT; }### Answer:
@Test public void testGetNewRuleAnnotationClauseName() { final RuleAnnotationClause ruleAnnotationClause1 = new RuleAnnotationClause(); dtable.getAnnotations().add(ruleAnnotationClause1); ruleAnnotationClause1.getName().setValue(DecisionTableDefaultValueUtilities.getNewRuleAnnotationClauseName(dtable)); assertThat(ruleAnnotationClause1.getName().getValue()).isEqualTo(DecisionTableDefaultValueUtilities.RULE_ANNOTATION_CLAUSE_PREFIX + "1"); final RuleAnnotationClause ruleAnnotationClause2 = new RuleAnnotationClause(); dtable.getAnnotations().add(ruleAnnotationClause2); ruleAnnotationClause2.getName().setValue(DecisionTableDefaultValueUtilities.getNewRuleAnnotationClauseName(dtable)); assertThat(ruleAnnotationClause2.getName().getValue()).isEqualTo(DecisionTableDefaultValueUtilities.RULE_ANNOTATION_CLAUSE_PREFIX + "2"); }
@Test public void testGetNewRuleAnnotationClauseNameWithExistingAnnotationClause() { final RuleAnnotationClause ruleAnnotationClause1 = new RuleAnnotationClause(); dtable.getAnnotations().add(ruleAnnotationClause1); ruleAnnotationClause1.getName().setValue("something"); final RuleAnnotationClause ruleAnnotationClause2 = new RuleAnnotationClause(); dtable.getAnnotations().add(ruleAnnotationClause2); ruleAnnotationClause2.getName().setValue(DecisionTableDefaultValueUtilities.getNewRuleAnnotationClauseName(dtable)); assertThat(ruleAnnotationClause2.getName().getValue()).isEqualTo(DecisionTableDefaultValueUtilities.RULE_ANNOTATION_CLAUSE_PREFIX + "1"); } |
### Question:
InputClauseColumnHeaderMetaData extends ValueAndDataTypeHeaderMetaData<Text, HasText> implements HasCellEditorControls,
HasListSelectorControl { @Override protected boolean isEmptyValue(final Text value) { return Objects.isNull(value) || StringUtils.isEmpty(value.getValue()); } InputClauseColumnHeaderMetaData(final HasText hasValue,
final Supplier<HasTypeRef> hasTypeRef,
final Consumer<HasText> clearValueConsumer,
final BiConsumer<HasText, Text> setValueConsumer,
final BiConsumer<HasTypeRef, QName> setTypeRefConsumer,
final TranslationService translationService,
final CellEditorControlsView.Presenter cellEditorControls,
final ValueAndDataTypePopoverView.Presenter editor,
final ListSelectorView.Presenter listSelector,
final BiFunction<Integer, Integer, List<HasListSelectorControl.ListSelectorItem>> listSelectorItemsSupplier,
final Consumer<HasListSelectorControl.ListSelectorItem> listSelectorItemConsumer); @Override Text toModelValue(final String componentValue); @Override String toWidgetValue(final Text modelValue); @Override String getValueLabel(); @Override String normaliseValue(final String componentValue); @Override Text getValue(); @Override String getColumnGroup(); @Override String getPopoverTitle(); @Override Optional<Editor> getEditor(); @Override List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); }### Answer:
@Test public void testIsEmptyValue_WhenNull() { assertThat(headerMetaData.isEmptyValue(null)).isTrue(); }
@Test public void testIsEmptyValue_WhenEmptyString() { assertThat(headerMetaData.isEmptyValue(new Text())).isTrue(); } |
### Question:
InputClauseColumnHeaderMetaData extends ValueAndDataTypeHeaderMetaData<Text, HasText> implements HasCellEditorControls,
HasListSelectorControl { @Override public Text toModelValue(final String componentValue) { return new Text(componentValue); } InputClauseColumnHeaderMetaData(final HasText hasValue,
final Supplier<HasTypeRef> hasTypeRef,
final Consumer<HasText> clearValueConsumer,
final BiConsumer<HasText, Text> setValueConsumer,
final BiConsumer<HasTypeRef, QName> setTypeRefConsumer,
final TranslationService translationService,
final CellEditorControlsView.Presenter cellEditorControls,
final ValueAndDataTypePopoverView.Presenter editor,
final ListSelectorView.Presenter listSelector,
final BiFunction<Integer, Integer, List<HasListSelectorControl.ListSelectorItem>> listSelectorItemsSupplier,
final Consumer<HasListSelectorControl.ListSelectorItem> listSelectorItemConsumer); @Override Text toModelValue(final String componentValue); @Override String toWidgetValue(final Text modelValue); @Override String getValueLabel(); @Override String normaliseValue(final String componentValue); @Override Text getValue(); @Override String getColumnGroup(); @Override String getPopoverTitle(); @Override Optional<Editor> getEditor(); @Override List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); }### Answer:
@Test public void testToModelValue() { assertThat(headerMetaData.toModelValue(VALUE).getValue()).isEqualTo(VALUE); } |
### Question:
InputClauseColumnHeaderMetaData extends ValueAndDataTypeHeaderMetaData<Text, HasText> implements HasCellEditorControls,
HasListSelectorControl { @Override public String toWidgetValue(final Text modelValue) { return modelValue.getValue(); } InputClauseColumnHeaderMetaData(final HasText hasValue,
final Supplier<HasTypeRef> hasTypeRef,
final Consumer<HasText> clearValueConsumer,
final BiConsumer<HasText, Text> setValueConsumer,
final BiConsumer<HasTypeRef, QName> setTypeRefConsumer,
final TranslationService translationService,
final CellEditorControlsView.Presenter cellEditorControls,
final ValueAndDataTypePopoverView.Presenter editor,
final ListSelectorView.Presenter listSelector,
final BiFunction<Integer, Integer, List<HasListSelectorControl.ListSelectorItem>> listSelectorItemsSupplier,
final Consumer<HasListSelectorControl.ListSelectorItem> listSelectorItemConsumer); @Override Text toModelValue(final String componentValue); @Override String toWidgetValue(final Text modelValue); @Override String getValueLabel(); @Override String normaliseValue(final String componentValue); @Override Text getValue(); @Override String getColumnGroup(); @Override String getPopoverTitle(); @Override Optional<Editor> getEditor(); @Override List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); }### Answer:
@Test public void testToWidgetValue() { assertThat(headerMetaData.toWidgetValue(new Text(VALUE))).isEqualTo(VALUE); } |
### Question:
InputClauseColumnHeaderMetaData extends ValueAndDataTypeHeaderMetaData<Text, HasText> implements HasCellEditorControls,
HasListSelectorControl { @Override public String getValueLabel() { return translationService.getTranslation(DMNEditorConstants.DecisionTableEditor_InputClauseColumnHeaderMetaData_ValueLabel); } InputClauseColumnHeaderMetaData(final HasText hasValue,
final Supplier<HasTypeRef> hasTypeRef,
final Consumer<HasText> clearValueConsumer,
final BiConsumer<HasText, Text> setValueConsumer,
final BiConsumer<HasTypeRef, QName> setTypeRefConsumer,
final TranslationService translationService,
final CellEditorControlsView.Presenter cellEditorControls,
final ValueAndDataTypePopoverView.Presenter editor,
final ListSelectorView.Presenter listSelector,
final BiFunction<Integer, Integer, List<HasListSelectorControl.ListSelectorItem>> listSelectorItemsSupplier,
final Consumer<HasListSelectorControl.ListSelectorItem> listSelectorItemConsumer); @Override Text toModelValue(final String componentValue); @Override String toWidgetValue(final Text modelValue); @Override String getValueLabel(); @Override String normaliseValue(final String componentValue); @Override Text getValue(); @Override String getColumnGroup(); @Override String getPopoverTitle(); @Override Optional<Editor> getEditor(); @Override List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); }### Answer:
@Test public void testGetValueLabel() { assertThat(headerMetaData.getValueLabel()).isEqualTo(DMNEditorConstants.DecisionTableEditor_InputClauseColumnHeaderMetaData_ValueLabel); } |
### Question:
ItemDefinitionPropertyConverter { static QName wbTypeRefFromDMN(final org.kie.dmn.model.api.ItemDefinition dmn) { final QName wbQName = QNamePropertyConverter.wbFromDMN(dmn.getTypeRef(), dmn); final QName undefinedQName = BuiltInType.UNDEFINED.asQName(); return Objects.equals(wbQName, undefinedQName) ? null : wbQName; } static ItemDefinition wbFromDMN(final org.kie.dmn.model.api.ItemDefinition dmn); static org.kie.dmn.model.api.ItemDefinition dmnFromWB(final ItemDefinition wb); }### Answer:
@Test public void testWbTypeRefFromDMNWhenQNameIsUndefined() { final org.kie.dmn.model.api.ItemDefinition dmn = mock(org.kie.dmn.model.api.ItemDefinition.class); final javax.xml.namespace.QName dmnQName = null; when(dmn.getTypeRef()).thenReturn(dmnQName); final QName actualQName = wbTypeRefFromDMN(dmn); assertNull(actualQName); }
@Test public void testWbTypeRefFromDMNWhenQNameIsNotUndefined() { final String qNameLocalPart = "string"; final String qNamePrefix = "qName prefix"; final org.kie.dmn.model.api.ItemDefinition dmn = mock(org.kie.dmn.model.api.ItemDefinition.class); final javax.xml.namespace.QName dmnQName = mock(javax.xml.namespace.QName.class); final QName expectedQName = BuiltInType.STRING.asQName(); when(dmn.getTypeRef()).thenReturn(dmnQName); when(dmnQName.getLocalPart()).thenReturn(qNameLocalPart); when(dmnQName.getPrefix()).thenReturn(qNamePrefix); final QName actualQName = wbTypeRefFromDMN(dmn); assertEquals(actualQName, expectedQName); } |
### Question:
InputClauseColumnHeaderMetaData extends ValueAndDataTypeHeaderMetaData<Text, HasText> implements HasCellEditorControls,
HasListSelectorControl { @Override public String normaliseValue(final String componentValue) { return componentValue; } InputClauseColumnHeaderMetaData(final HasText hasValue,
final Supplier<HasTypeRef> hasTypeRef,
final Consumer<HasText> clearValueConsumer,
final BiConsumer<HasText, Text> setValueConsumer,
final BiConsumer<HasTypeRef, QName> setTypeRefConsumer,
final TranslationService translationService,
final CellEditorControlsView.Presenter cellEditorControls,
final ValueAndDataTypePopoverView.Presenter editor,
final ListSelectorView.Presenter listSelector,
final BiFunction<Integer, Integer, List<HasListSelectorControl.ListSelectorItem>> listSelectorItemsSupplier,
final Consumer<HasListSelectorControl.ListSelectorItem> listSelectorItemConsumer); @Override Text toModelValue(final String componentValue); @Override String toWidgetValue(final Text modelValue); @Override String getValueLabel(); @Override String normaliseValue(final String componentValue); @Override Text getValue(); @Override String getColumnGroup(); @Override String getPopoverTitle(); @Override Optional<Editor> getEditor(); @Override List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); }### Answer:
@Test public void testNormaliseValue() { final String value = " " + VALUE + " "; assertThat(headerMetaData.normaliseValue(value)).isEqualTo(value); } |
### Question:
InputClauseColumnHeaderMetaData extends ValueAndDataTypeHeaderMetaData<Text, HasText> implements HasCellEditorControls,
HasListSelectorControl { @Override public Text getValue() { return hasValue.orElse(HasText.NOP).getValue(); } InputClauseColumnHeaderMetaData(final HasText hasValue,
final Supplier<HasTypeRef> hasTypeRef,
final Consumer<HasText> clearValueConsumer,
final BiConsumer<HasText, Text> setValueConsumer,
final BiConsumer<HasTypeRef, QName> setTypeRefConsumer,
final TranslationService translationService,
final CellEditorControlsView.Presenter cellEditorControls,
final ValueAndDataTypePopoverView.Presenter editor,
final ListSelectorView.Presenter listSelector,
final BiFunction<Integer, Integer, List<HasListSelectorControl.ListSelectorItem>> listSelectorItemsSupplier,
final Consumer<HasListSelectorControl.ListSelectorItem> listSelectorItemConsumer); @Override Text toModelValue(final String componentValue); @Override String toWidgetValue(final Text modelValue); @Override String getValueLabel(); @Override String normaliseValue(final String componentValue); @Override Text getValue(); @Override String getColumnGroup(); @Override String getPopoverTitle(); @Override Optional<Editor> getEditor(); @Override List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); }### Answer:
@Test public void testGetValue() { when(hasValue.getValue()).thenReturn(new Text(VALUE)); assertThat(headerMetaData.getValue()).isNotNull(); assertThat(headerMetaData.getValue().getValue()).isEqualTo(VALUE); } |
### Question:
InputClauseColumnHeaderMetaData extends ValueAndDataTypeHeaderMetaData<Text, HasText> implements HasCellEditorControls,
HasListSelectorControl { @Override public String getPopoverTitle() { return translationService.getTranslation(DMNEditorConstants.DecisionTableEditor_EditInputClause); } InputClauseColumnHeaderMetaData(final HasText hasValue,
final Supplier<HasTypeRef> hasTypeRef,
final Consumer<HasText> clearValueConsumer,
final BiConsumer<HasText, Text> setValueConsumer,
final BiConsumer<HasTypeRef, QName> setTypeRefConsumer,
final TranslationService translationService,
final CellEditorControlsView.Presenter cellEditorControls,
final ValueAndDataTypePopoverView.Presenter editor,
final ListSelectorView.Presenter listSelector,
final BiFunction<Integer, Integer, List<HasListSelectorControl.ListSelectorItem>> listSelectorItemsSupplier,
final Consumer<HasListSelectorControl.ListSelectorItem> listSelectorItemConsumer); @Override Text toModelValue(final String componentValue); @Override String toWidgetValue(final Text modelValue); @Override String getValueLabel(); @Override String normaliseValue(final String componentValue); @Override Text getValue(); @Override String getColumnGroup(); @Override String getPopoverTitle(); @Override Optional<Editor> getEditor(); @Override List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); }### Answer:
@Test public void testGetPopoverTitle() { assertThat(headerMetaData.getPopoverTitle()).isEqualTo(DMNEditorConstants.DecisionTableEditor_EditInputClause); } |
### Question:
DecisionRuleFactory { public static DecisionRule makeDecisionRule(final DecisionTable dtable) { final DecisionRule rule = new DecisionRule(); for (int ie = 0; ie < dtable.getInput().size(); ie++) { final UnaryTests ut = new UnaryTests(); ut.getText().setValue(DecisionTableDefaultValueUtilities.INPUT_CLAUSE_UNARY_TEST_TEXT); rule.getInputEntry().add(ut); ut.setParent(rule); } for (int oe = 0; oe < dtable.getOutput().size(); oe++) { final LiteralExpression le = new LiteralExpression(); le.getText().setValue(DecisionTableDefaultValueUtilities.OUTPUT_CLAUSE_EXPRESSION_TEXT); rule.getOutputEntry().add(le); le.setParent(rule); } for (int index = 0; index < dtable.getAnnotations().size(); index++) { final RuleAnnotationClauseText ruleAnnotationClauseText = new RuleAnnotationClauseText(); ruleAnnotationClauseText.getText().setValue(DecisionTableDefaultValueUtilities.RULE_ANNOTATION_CLAUSE_EXPRESSION_TEXT); rule.getAnnotationEntry().add(ruleAnnotationClauseText); ruleAnnotationClauseText.setParent(rule); } rule.setParent(dtable); return rule; } static DecisionRule makeDecisionRule(final DecisionTable dtable); static DecisionRule duplicateDecisionRule(final int index,
final DecisionTable dtable); }### Answer:
@Test public void testMakeDecisionRule() { final DecisionRule rule = DecisionRuleFactory.makeDecisionRule(dtable); final List<UnaryTests> inputEntries = rule.getInputEntry(); assertThat(inputEntries.size()).isEqualTo(2); assertThat(inputEntries) .allSatisfy(unaryTests -> assertUnaryTestsText(unaryTests, DecisionTableDefaultValueUtilities.INPUT_CLAUSE_UNARY_TEST_TEXT)) .allSatisfy(unaryTests -> assertThat(unaryTests.getConstraintType()).isEqualTo(NONE)) .allSatisfy(unaryTests -> assertThat(unaryTests.getParent()).isEqualTo(rule)); final List<LiteralExpression> outputEntries = rule.getOutputEntry(); assertThat(outputEntries.size()).isEqualTo(2); assertThat(outputEntries) .allSatisfy(literalExpression -> assertLiteralExpressionText(literalExpression, DecisionTableDefaultValueUtilities.OUTPUT_CLAUSE_EXPRESSION_TEXT)) .allSatisfy(literalExpression -> assertThat(literalExpression.getParent()).isEqualTo(rule)); final List<RuleAnnotationClauseText> annotationEntries = rule.getAnnotationEntry(); assertThat(annotationEntries.size()).isEqualTo(2); assertThat(annotationEntries) .allSatisfy(clauseText -> assertAnnotationClauseText(clauseText, DecisionTableDefaultValueUtilities.RULE_ANNOTATION_CLAUSE_EXPRESSION_TEXT)) .allSatisfy(clauseText -> assertThat(clauseText.getParent()).isEqualTo(rule)); assertThat(rule.getParent()).isEqualTo(dtable); } |
### Question:
RuleAnnotationClauseColumnHeaderMetaData extends EditableTextHeaderMetaData<TextBox, TextBoxDOMElement> implements HasListSelectorControl,
HasCellEditorControls { @Override public String getColumnGroup() { return COLUMN_GROUP; } RuleAnnotationClauseColumnHeaderMetaData(final Supplier<String> titleGetter,
final Consumer<String> titleSetter,
final SingletonDOMElementFactory<TextBox, TextBoxDOMElement> factory,
final Optional<String> placeHolder,
final BiFunction<Integer, Integer, List<ListSelectorItem>> listSelectorItemsSupplier,
final ListSelectorView.Presenter listSelector,
final Consumer<HasListSelectorControl.ListSelectorItem> listSelectorItemConsumer); @Override Optional<String> getPlaceHolder(); @Override Optional<Editor> getEditor(); @Override String getColumnGroup(); @Override List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override boolean equals(final Object o); @Override int hashCode(); static final String COLUMN_GROUP; }### Answer:
@Test public void testGetColumnGroup() { final String actual = column.getColumnGroup(); assertEquals(COLUMN_GROUP, actual); } |
### Question:
RuleAnnotationClauseColumnHeaderMetaData extends EditableTextHeaderMetaData<TextBox, TextBoxDOMElement> implements HasListSelectorControl,
HasCellEditorControls { @Override public List<ListSelectorItem> getItems(final int uiRowIndex, final int uiColumnIndex) { return listSelectorItemsSupplier.apply(uiRowIndex, uiColumnIndex); } RuleAnnotationClauseColumnHeaderMetaData(final Supplier<String> titleGetter,
final Consumer<String> titleSetter,
final SingletonDOMElementFactory<TextBox, TextBoxDOMElement> factory,
final Optional<String> placeHolder,
final BiFunction<Integer, Integer, List<ListSelectorItem>> listSelectorItemsSupplier,
final ListSelectorView.Presenter listSelector,
final Consumer<HasListSelectorControl.ListSelectorItem> listSelectorItemConsumer); @Override Optional<String> getPlaceHolder(); @Override Optional<Editor> getEditor(); @Override String getColumnGroup(); @Override List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override boolean equals(final Object o); @Override int hashCode(); static final String COLUMN_GROUP; }### Answer:
@Test public void testGetItems() { final int uiRowIndex = 5; final int uiColumnIndex = 6; final List<HasListSelectorControl.ListSelectorItem> expectedItems = mock(List.class); when(listSelectorItemsSupplier.apply(uiRowIndex, uiColumnIndex)).thenReturn(expectedItems); final List<HasListSelectorControl.ListSelectorItem> actualItems = column.getItems(uiRowIndex, uiColumnIndex); assertEquals(expectedItems, actualItems); verify(listSelectorItemsSupplier).apply(uiRowIndex, uiColumnIndex); } |
### Question:
RuleAnnotationClauseColumnHeaderMetaData extends EditableTextHeaderMetaData<TextBox, TextBoxDOMElement> implements HasListSelectorControl,
HasCellEditorControls { @Override public Optional<Editor> getEditor() { return Optional.of(listSelector); } RuleAnnotationClauseColumnHeaderMetaData(final Supplier<String> titleGetter,
final Consumer<String> titleSetter,
final SingletonDOMElementFactory<TextBox, TextBoxDOMElement> factory,
final Optional<String> placeHolder,
final BiFunction<Integer, Integer, List<ListSelectorItem>> listSelectorItemsSupplier,
final ListSelectorView.Presenter listSelector,
final Consumer<HasListSelectorControl.ListSelectorItem> listSelectorItemConsumer); @Override Optional<String> getPlaceHolder(); @Override Optional<Editor> getEditor(); @Override String getColumnGroup(); @Override List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override boolean equals(final Object o); @Override int hashCode(); static final String COLUMN_GROUP; }### Answer:
@Test public void testGetEditor() { final Optional<HasCellEditorControls.Editor> actual = column.getEditor(); assertEquals(listSelector, actual.get()); } |
### Question:
RuleAnnotationClauseColumnHeaderMetaData extends EditableTextHeaderMetaData<TextBox, TextBoxDOMElement> implements HasListSelectorControl,
HasCellEditorControls { @Override public void onItemSelected(final ListSelectorItem item) { listSelectorItemConsumer.accept(item); } RuleAnnotationClauseColumnHeaderMetaData(final Supplier<String> titleGetter,
final Consumer<String> titleSetter,
final SingletonDOMElementFactory<TextBox, TextBoxDOMElement> factory,
final Optional<String> placeHolder,
final BiFunction<Integer, Integer, List<ListSelectorItem>> listSelectorItemsSupplier,
final ListSelectorView.Presenter listSelector,
final Consumer<HasListSelectorControl.ListSelectorItem> listSelectorItemConsumer); @Override Optional<String> getPlaceHolder(); @Override Optional<Editor> getEditor(); @Override String getColumnGroup(); @Override List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override boolean equals(final Object o); @Override int hashCode(); static final String COLUMN_GROUP; }### Answer:
@Test public void testOnItemSelected() { final HasListSelectorControl.ListSelectorItem item = mock(HasListSelectorControl.ListSelectorItem.class); column.onItemSelected(item); verify(listSelectorItemConsumer).accept(item); } |
### Question:
RuleAnnotationClauseColumnHeaderMetaData extends EditableTextHeaderMetaData<TextBox, TextBoxDOMElement> implements HasListSelectorControl,
HasCellEditorControls { @Override public Optional<String> getPlaceHolder() { return placeHolder; } RuleAnnotationClauseColumnHeaderMetaData(final Supplier<String> titleGetter,
final Consumer<String> titleSetter,
final SingletonDOMElementFactory<TextBox, TextBoxDOMElement> factory,
final Optional<String> placeHolder,
final BiFunction<Integer, Integer, List<ListSelectorItem>> listSelectorItemsSupplier,
final ListSelectorView.Presenter listSelector,
final Consumer<HasListSelectorControl.ListSelectorItem> listSelectorItemConsumer); @Override Optional<String> getPlaceHolder(); @Override Optional<Editor> getEditor(); @Override String getColumnGroup(); @Override List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override boolean equals(final Object o); @Override int hashCode(); static final String COLUMN_GROUP; }### Answer:
@Test public void testGetPlaceHolder() { assertThat(headerMetaData.getPlaceHolder()).isEqualTo(placeHolder); } |
### Question:
RuleAnnotationClauseColumnHeaderMetaData extends EditableTextHeaderMetaData<TextBox, TextBoxDOMElement> implements HasListSelectorControl,
HasCellEditorControls { @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } if (!super.equals(o)) { return false; } final RuleAnnotationClauseColumnHeaderMetaData that = (RuleAnnotationClauseColumnHeaderMetaData) o; return Objects.equals(listSelectorItemsSupplier, that.listSelectorItemsSupplier) && Objects.equals(listSelector, that.listSelector) && Objects.equals(listSelectorItemConsumer, that.listSelectorItemConsumer) && Objects.equals(placeHolder, that.placeHolder); } RuleAnnotationClauseColumnHeaderMetaData(final Supplier<String> titleGetter,
final Consumer<String> titleSetter,
final SingletonDOMElementFactory<TextBox, TextBoxDOMElement> factory,
final Optional<String> placeHolder,
final BiFunction<Integer, Integer, List<ListSelectorItem>> listSelectorItemsSupplier,
final ListSelectorView.Presenter listSelector,
final Consumer<HasListSelectorControl.ListSelectorItem> listSelectorItemConsumer); @Override Optional<String> getPlaceHolder(); @Override Optional<Editor> getEditor(); @Override String getColumnGroup(); @Override List<ListSelectorItem> getItems(final int uiRowIndex,
final int uiColumnIndex); @Override void onItemSelected(final ListSelectorItem item); @Override boolean equals(final Object o); @Override int hashCode(); static final String COLUMN_GROUP; }### Answer:
@Test public void testEquals() { final Supplier<String> otherGetter = mock(Supplier.class); when(otherGetter.get()).thenReturn(""); final RuleAnnotationClauseColumnHeaderMetaData otherEqualsColumn = new RuleAnnotationClauseColumnHeaderMetaData(titleGetter, titleSetter, factory, placeHolder, listSelectorItemsSupplier, listSelector, listSelectorItemConsumer); assertEquals(column, otherEqualsColumn); assertEquals(column.hashCode(), otherEqualsColumn.hashCode()); final RuleAnnotationClauseColumnHeaderMetaData notEqualsColumn = new RuleAnnotationClauseColumnHeaderMetaData(otherGetter, titleSetter, factory, placeHolder, listSelectorItemsSupplier, listSelector, listSelectorItemConsumer); assertNotEquals(column, notEqualsColumn); assertNotEquals(column.hashCode(), notEqualsColumn.hashCode()); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.