method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
DMNPathsHelperImpl implements DMNPathsHelper { @Override public List<Path> getDMNModelsPaths(final WorkspaceProject workspaceProject) { if (workspaceProject != null) { return getPathsByWorkspaceProject(dmnQueryTerms(workspaceProject.getRootPath().toURI())); } else { return getStandalonePaths(dmnModelFilter()); } } DMNPathsHelperImpl(); @Inject DMNPathsHelperImpl(final RefactoringQueryService refactoringQueryService,
final DMNImportTypesHelper importTypesHelper,
final @Named("ioStrategy") IOService ioService); @Override List<Path> getModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getDMNModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getPMMLModelsPaths(final WorkspaceProject workspaceProject); @Override String getRelativeURI(final Path dmnModelPath,
final Path includedModelPath); }### Answer:
@Test public void testGetDMNModelsPathsWhenWorkspaceProjectIsNull() { doTestGetPathsWhenWorkspaceProjectIsNull(workspaceProject1 -> pathsHelper.getDMNModelsPaths(null)); }
@Test public void testGetDMNModelsPathsWhenWorkspaceProjectIsNotNull() { doTestGetPathsWhenWorkspaceProjectIsNotNull(workspaceProject -> pathsHelper.getDMNModelsPaths(workspaceProject)); } |
### Question:
TreeList { public List<TreeListItem> getSelectedItems() { return getCurrentItems().stream() .filter(item -> item.getIsSelected()) .collect(Collectors.toList()); } @Inject TreeList(final View view); void populate(final List<TreeListItem> items); void refresh(); List<TreeListItem> getCurrentItems(); void clear(); Node getElement(); void clearSelection(); List<TreeListItem> getSelectedItems(); void setOnSelectionChanged(final Consumer<List<TreeListItem>> onSelectionChanged); }### Answer:
@Test public void testGetSelectedItems() { when(itemThree.getIsSelected()).thenReturn(true); final List<TreeListItem> selectedItems = treeList.getSelectedItems(); assertTrue(selectedItems.contains(itemThree)); assertFalse(selectedItems.contains(itemOne)); assertFalse(selectedItems.contains(itemTwo)); } |
### Question:
TreeList { @SuppressWarnings("unused") void selectionChanged(final TreeListItem treeListItem) { callOnSelectionChanged(); } @Inject TreeList(final View view); void populate(final List<TreeListItem> items); void refresh(); List<TreeListItem> getCurrentItems(); void clear(); Node getElement(); void clearSelection(); List<TreeListItem> getSelectedItems(); void setOnSelectionChanged(final Consumer<List<TreeListItem>> onSelectionChanged); }### Answer:
@Test public void testSelectionChanged() { final TreeListItem treeListItem = mock(TreeListItem.class); doNothing().when(treeList).callOnSelectionChanged(); treeList.selectionChanged(treeListItem); verify(treeList).callOnSelectionChanged(); } |
### Question:
TreeList { void callOnSelectionChanged() { if (!Objects.isNull(getOnSelectionChanged())) { getOnSelectionChanged().accept(getSelectedItems()); } } @Inject TreeList(final View view); void populate(final List<TreeListItem> items); void refresh(); List<TreeListItem> getCurrentItems(); void clear(); Node getElement(); void clearSelection(); List<TreeListItem> getSelectedItems(); void setOnSelectionChanged(final Consumer<List<TreeListItem>> onSelectionChanged); }### Answer:
@Test public void testCallOnSelectionChanged() { final List selectedItems = mock(List.class); final Consumer consumer = mock(Consumer.class); doReturn(consumer).when(treeList).getOnSelectionChanged(); doReturn(selectedItems).when(treeList).getSelectedItems(); treeList.callOnSelectionChanged(); verify(consumer).accept(selectedItems); } |
### Question:
TreeListSubItem { public Node getElement() { return view.getElement(); } @Inject TreeListSubItem(final View view); String getDescription(); void setDescription(final String description); String getDetails(); void setDetails(final String details); Node getElement(); }### Answer:
@Test public void testGetElement() { final Node actual = subItem.getElement(); assertEquals(element, actual); } |
### Question:
TreeListItem { @PostConstruct void setup() { view.init(this); } @Inject TreeListItem(final View view); Node getElement(); String getDescription(); void setDescription(final String description); void addSubItem(final TreeListSubItem subItem); List<TreeListSubItem> getSubItems(); void updateView(); void setIsSelected(final boolean value); boolean getIsSelected(); void setDataSource(final DataObject dataSource); DataObject getDataSource(); void setOnIsSelectedChanged(final Consumer<TreeListItem> onIsSelectedChanged); Consumer<TreeListItem> getOnIsSelectedChanged(); }### Answer:
@Test public void testSetup() { treeListItem.setup(); verify(view).init(treeListItem); } |
### Question:
TreeListItem { public Node getElement() { return view.getElement(); } @Inject TreeListItem(final View view); Node getElement(); String getDescription(); void setDescription(final String description); void addSubItem(final TreeListSubItem subItem); List<TreeListSubItem> getSubItems(); void updateView(); void setIsSelected(final boolean value); boolean getIsSelected(); void setDataSource(final DataObject dataSource); DataObject getDataSource(); void setOnIsSelectedChanged(final Consumer<TreeListItem> onIsSelectedChanged); Consumer<TreeListItem> getOnIsSelectedChanged(); }### Answer:
@Test public void testGetElement() { final Node actual = treeListItem.getElement(); assertEquals(viewElement, actual); } |
### Question:
TreeListItem { public void addSubItem(final TreeListSubItem subItem) { subItems.add(subItem); } @Inject TreeListItem(final View view); Node getElement(); String getDescription(); void setDescription(final String description); void addSubItem(final TreeListSubItem subItem); List<TreeListSubItem> getSubItems(); void updateView(); void setIsSelected(final boolean value); boolean getIsSelected(); void setDataSource(final DataObject dataSource); DataObject getDataSource(); void setOnIsSelectedChanged(final Consumer<TreeListItem> onIsSelectedChanged); Consumer<TreeListItem> getOnIsSelectedChanged(); }### Answer:
@Test public void testAddSubItem() { final TreeListSubItem subItem = mock(TreeListSubItem.class); treeListItem.addSubItem(subItem); } |
### Question:
TreeListItem { public void updateView() { this.view.populate(this); } @Inject TreeListItem(final View view); Node getElement(); String getDescription(); void setDescription(final String description); void addSubItem(final TreeListSubItem subItem); List<TreeListSubItem> getSubItems(); void updateView(); void setIsSelected(final boolean value); boolean getIsSelected(); void setDataSource(final DataObject dataSource); DataObject getDataSource(); void setOnIsSelectedChanged(final Consumer<TreeListItem> onIsSelectedChanged); Consumer<TreeListItem> getOnIsSelectedChanged(); }### Answer:
@Test public void testUpdateView() { treeListItem.updateView(); verify(view).populate(treeListItem); } |
### Question:
TreeListItem { void callOnIsSelectedChanged() { if (!Objects.isNull(getOnIsSelectedChanged())) { getOnIsSelectedChanged().accept(this); } } @Inject TreeListItem(final View view); Node getElement(); String getDescription(); void setDescription(final String description); void addSubItem(final TreeListSubItem subItem); List<TreeListSubItem> getSubItems(); void updateView(); void setIsSelected(final boolean value); boolean getIsSelected(); void setDataSource(final DataObject dataSource); DataObject getDataSource(); void setOnIsSelectedChanged(final Consumer<TreeListItem> onIsSelectedChanged); Consumer<TreeListItem> getOnIsSelectedChanged(); }### Answer:
@Test public void testCallOnIsSelectedChanged() { final Consumer consumer = mock(Consumer.class); doReturn(consumer).when(treeListItem).getOnIsSelectedChanged(); treeListItem.callOnIsSelectedChanged(); verify(consumer).accept(treeListItem); } |
### Question:
DataTypeManagerStackStore { public List<String> get(final String uuid) { return Optional.ofNullable(typeStack.get(uuid)).orElse(new ArrayList<>()); } List<String> get(final String uuid); void put(final String uuid,
final List<String> types); void clear(); }### Answer:
@Test public void testGetWhenTypeStackHasTheUUID() { assertEquals(types, typeStack.get(uuid)); }
@Test public void testGetWhenTypeStackDoesNotHaveTheUUID() { final List<Object> expectedTypes = emptyList(); final List<String> actualTypes = typeStack.get("otherUUID"); assertEquals(expectedTypes, actualTypes); } |
### Question:
DataTypeManagerStackStore { public void put(final String uuid, final List<String> types) { typeStack.put(uuid, types); } List<String> get(final String uuid); void put(final String uuid,
final List<String> types); void clear(); }### Answer:
@Test public void testPut() { final String uuid = "456"; final List<String> expectedTypes = asList("tCompany", "tPerson"); typeStack.put(uuid, expectedTypes); final List<String> actualTypes = typeStack.get(uuid); assertEquals(expectedTypes, actualTypes); } |
### Question:
DataTypeManagerStackStore { public void clear() { typeStack.clear(); } List<String> get(final String uuid); void put(final String uuid,
final List<String> types); void clear(); }### Answer:
@Test public void testClear() { typeStack.clear(); assertEquals(0, typeStack.size()); } |
### Question:
HiddenHelper { public static void hide(final Element element) { element.classList.add(HIDDEN_CSS_CLASS); } static void hide(final Element element); static void show(final Element element); static boolean isHidden(final Element element); static final String HIDDEN_CSS_CLASS; }### Answer:
@Test public void testHide() { final Element element = mock(Element.class); final DOMTokenList classList = mock(DOMTokenList.class); element.classList = classList; HiddenHelper.hide(element); verify(classList).add(HIDDEN_CSS_CLASS); } |
### Question:
HiddenHelper { public static void show(final Element element) { element.classList.remove(HIDDEN_CSS_CLASS); } static void hide(final Element element); static void show(final Element element); static boolean isHidden(final Element element); static final String HIDDEN_CSS_CLASS; }### Answer:
@Test public void testShow() { final Element element = mock(Element.class); final DOMTokenList classList = mock(DOMTokenList.class); element.classList = classList; HiddenHelper.show(element); verify(classList).remove(HIDDEN_CSS_CLASS); } |
### Question:
HiddenHelper { public static boolean isHidden(final Element element) { return element.classList.contains(HIDDEN_CSS_CLASS); } static void hide(final Element element); static void show(final Element element); static boolean isHidden(final Element element); static final String HIDDEN_CSS_CLASS; }### Answer:
@Test public void testIsHiddenWhenElementIsHidden() { final Element element = mock(Element.class); final DOMTokenList classList = mock(DOMTokenList.class); element.classList = classList; when(classList.contains(HIDDEN_CSS_CLASS)).thenReturn(true); assertTrue(HiddenHelper.isHidden(element)); }
@Test public void testIsHiddenWhenElementIsNotHidden() { final Element element = mock(Element.class); final DOMTokenList classList = mock(DOMTokenList.class); element.classList = classList; when(classList.contains(HIDDEN_CSS_CLASS)).thenReturn(false); assertFalse(HiddenHelper.isHidden(element)); } |
### Question:
ItemDefinitionUtils { public Optional<ItemDefinition> findByName(final String name) { return all() .stream() .filter(itemDefinition -> itemDefinition.getName().getValue().equals(name)) .findFirst(); } @Inject ItemDefinitionUtils(final DMNGraphUtils dmnGraphUtils); Optional<ItemDefinition> findByName(final String name); List<ItemDefinition> all(); void addItemDefinitions(final List<ItemDefinition> newItemDefinitions); String getConstraintText(final ItemDefinition itemDefinition); QName normaliseTypeRef(final QName typeRef); }### Answer:
@Test public void testFindByName() { final String name = "item1"; final ItemDefinition item1 = makeItem("item1"); final ItemDefinition item2 = makeItem("item2"); final Definitions definitions = mock(Definitions.class); final List<ItemDefinition> itemDefinitions = asList(item1, item2); when(dmnGraphUtils.getModelDefinitions()).thenReturn(definitions); when(definitions.getItemDefinition()).thenReturn(itemDefinitions); final Optional<ItemDefinition> actual = utils.findByName(name); final Optional<ItemDefinition> expected = Optional.of(item1); assertEquals(expected, actual); } |
### Question:
ItemDefinitionUtils { public void addItemDefinitions(final List<ItemDefinition> newItemDefinitions) { final List<ItemDefinition> itemDefinitions = dmnGraphUtils.getModelDefinitions().getItemDefinition(); itemDefinitions.addAll(newItemDefinitions); } @Inject ItemDefinitionUtils(final DMNGraphUtils dmnGraphUtils); Optional<ItemDefinition> findByName(final String name); List<ItemDefinition> all(); void addItemDefinitions(final List<ItemDefinition> newItemDefinitions); String getConstraintText(final ItemDefinition itemDefinition); QName normaliseTypeRef(final QName typeRef); }### Answer:
@Test public void testAddItemDefinitions() { final Definitions definitions = mock(Definitions.class); final ItemDefinition itemDefinition1 = mock(ItemDefinition.class); final ItemDefinition itemDefinition2 = mock(ItemDefinition.class); final ItemDefinition itemDefinition3 = mock(ItemDefinition.class); final ItemDefinition itemDefinition4 = mock(ItemDefinition.class); final List<ItemDefinition> newItemDefinitions = asList(itemDefinition1, itemDefinition3); final List<ItemDefinition> expectedItemDefinitions = asList(itemDefinition2, itemDefinition4, itemDefinition1, itemDefinition3); final List<ItemDefinition> actualItemDefinitions = new ArrayList<>(asList(itemDefinition2, itemDefinition4)); when(dmnGraphUtils.getModelDefinitions()).thenReturn(definitions); when(definitions.getItemDefinition()).thenReturn(actualItemDefinitions); utils.addItemDefinitions(newItemDefinitions); assertEquals(expectedItemDefinitions, actualItemDefinitions); } |
### Question:
ItemDefinitionUtils { Optional<String> getPrefixForNamespaceURI(final String namespace) { final Definitions definitions = dmnGraphUtils.getModelDefinitions(); return definitions == null ? Optional.empty() : definitions.getPrefixForNamespaceURI(namespace); } @Inject ItemDefinitionUtils(final DMNGraphUtils dmnGraphUtils); Optional<ItemDefinition> findByName(final String name); List<ItemDefinition> all(); void addItemDefinitions(final List<ItemDefinition> newItemDefinitions); String getConstraintText(final ItemDefinition itemDefinition); QName normaliseTypeRef(final QName typeRef); }### Answer:
@Test public void testGetPrefixForNamespaceURIWhenDefinitionsIsNull() { final String namespaceURI = FEEL.getUri(); when(dmnGraphUtils.getModelDefinitions()).thenReturn(null); final Optional<String> prefix = utils.getPrefixForNamespaceURI(namespaceURI); assertFalse(prefix.isPresent()); }
@Test public void testGetPrefixForNamespaceURIWhenPrefixForNamespaceURIIsNotPresent() { final String namespaceURI = FEEL.getUri(); final Definitions definitions = mock(Definitions.class); when(dmnGraphUtils.getModelDefinitions()).thenReturn(definitions); when(definitions.getPrefixForNamespaceURI(namespaceURI)).thenReturn(Optional.empty()); final Optional<String> prefix = utils.getPrefixForNamespaceURI(namespaceURI); assertFalse(prefix.isPresent()); }
@Test public void testGetPrefixForNamespaceURIWhenPrefixForNamespaceURIIsPresent() { final String namespaceURI = FEEL.getUri(); final Definitions definitions = mock(Definitions.class); final Optional<String> expectedPrefix = Optional.of("prefix"); when(dmnGraphUtils.getModelDefinitions()).thenReturn(definitions); when(definitions.getPrefixForNamespaceURI(namespaceURI)).thenReturn(expectedPrefix); final Optional<String> actualPrefix = utils.getPrefixForNamespaceURI(namespaceURI); assertEquals(expectedPrefix, actualPrefix); } |
### Question:
BindingPropertyConverter { public static Binding wbFromDMN(final org.kie.dmn.model.api.Binding dmn, final BiConsumer<String, HasComponentWidths> hasComponentWidthsConsumer) { if (dmn == null) { return null; } final InformationItem convertedParameter = InformationItemPropertyConverter.wbFromDMN(dmn.getParameter()); final Expression convertedExpression = ExpressionPropertyConverter.wbFromDMN(dmn.getExpression(), hasComponentWidthsConsumer); final Binding result = new Binding(); if (convertedParameter != null) { convertedParameter.setParent(result); } result.setParameter(convertedParameter); if (convertedExpression != null) { convertedExpression.setParent(result); } result.setExpression(convertedExpression); return result; } static Binding wbFromDMN(final org.kie.dmn.model.api.Binding dmn,
final BiConsumer<String, HasComponentWidths> hasComponentWidthsConsumer); static org.kie.dmn.model.api.Binding dmnFromWB(final Binding wb,
final Consumer<ComponentWidths> componentWidthsConsumer); }### Answer:
@Test public void testWBFromDMN() { final org.kie.dmn.model.api.Binding dmn = new TBinding(); final org.kie.dmn.model.api.InformationItem informationItem = new TInformationItem(); dmn.setParameter(informationItem); final org.kie.dmn.model.api.LiteralExpression literalExpression = new TLiteralExpression(); literalExpression.setId(EXPRESSION_UUID); dmn.setExpression(literalExpression); final Binding wb = BindingPropertyConverter.wbFromDMN(dmn, hasComponentWidthsConsumer); assertThat(wb).isNotNull(); assertThat(wb.getParameter()).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:
ItemDefinitionUtils { public String getConstraintText(final ItemDefinition itemDefinition) { return Optional .ofNullable(itemDefinition.getAllowedValues()) .map(UnaryTests::getText) .orElse(new Text()) .getValue(); } @Inject ItemDefinitionUtils(final DMNGraphUtils dmnGraphUtils); Optional<ItemDefinition> findByName(final String name); List<ItemDefinition> all(); void addItemDefinitions(final List<ItemDefinition> newItemDefinitions); String getConstraintText(final ItemDefinition itemDefinition); QName normaliseTypeRef(final QName typeRef); }### Answer:
@Test public void testGetConstraintTextWhenItemDefinitionDoesNotHaveAllowedValues() { final ItemDefinition itemDefinition = mock(ItemDefinition.class); final String expectedText = ""; final String actualText = utils.getConstraintText(itemDefinition); assertEquals(expectedText, actualText); }
@Test public void testGetConstraintTextWhenItemDefinitionHasAllowedValues() { final ItemDefinition itemDefinition = mock(ItemDefinition.class); final UnaryTests allowedValues = mock(UnaryTests.class); final String expectedText = "(1..10)"; when(allowedValues.getText()).thenReturn(new Text(expectedText)); when(itemDefinition.getAllowedValues()).thenReturn(allowedValues); final String actualText = utils.getConstraintText(itemDefinition); assertEquals(expectedText, actualText); } |
### Question:
DataTypeNameIsDefaultTypeMessage extends ErrorMessage { @Override String getStrongMessage(final DataType dataType) { return translationService.format(DataTypeNameIsDefaultTypeMessage_StrongMessage); } @Inject DataTypeNameIsDefaultTypeMessage(final TranslationService translationService); }### Answer:
@Test public void testGetStrongMessage() { final DataType dataType = mock(DataType.class); final String expectedErrorMessage = "*Expected strong message.*"; final DataTypeNameIsDefaultTypeMessage errorMessage = new DataTypeNameIsDefaultTypeMessage(translationService); when(translationService.format(DataTypeNameIsDefaultTypeMessage_StrongMessage)).thenReturn(expectedErrorMessage); final String actualErrorMessage = errorMessage.getStrongMessage(dataType); assertEquals(expectedErrorMessage, actualErrorMessage); } |
### Question:
DataTypeNameIsDefaultTypeMessage extends ErrorMessage { @Override String getRegularMessage() { return translationService.format(DataTypeNameIsDefaultTypeMessage_RegularMessage); } @Inject DataTypeNameIsDefaultTypeMessage(final TranslationService translationService); }### Answer:
@Test public void testGetRegularMessage() { final String expectedErrorMessage = "Expected regular message."; final DataTypeNameIsDefaultTypeMessage errorMessage = new DataTypeNameIsDefaultTypeMessage(translationService); when(translationService.format(DataTypeNameIsDefaultTypeMessage_RegularMessage)).thenReturn(expectedErrorMessage); final String actualErrorMessage = errorMessage.getRegularMessage(); assertEquals(expectedErrorMessage, actualErrorMessage); } |
### Question:
ErrorMessage { public FlashMessage getFlashMessage(final DataType dataType) { return new FlashMessage(ERROR, getStrongMessage(dataType), getRegularMessage(), getErrorElementSelector(dataType)); } ErrorMessage(final TranslationService translationService); FlashMessage getFlashMessage(final DataType dataType); }### Answer:
@Test public void testGetFlashMessage() { final String uuid = "uuid"; final FlashMessage.Type expectedType = ERROR; final String expectedStrongMessage = "expectedStrongMessage"; final String expectedRegularMessage = "expectedRegularMessage"; final String expectedErrorElementSelector = "[data-row-uuid=\"uuid\"] [data-type-field=\"name-input\"]"; final DataType dataType = mock(DataType.class); final ErrorMessage errorMessage = new ErrorMessage(translationService) { @Override String getStrongMessage(final DataType dataType) { return expectedStrongMessage; } @Override String getRegularMessage() { return expectedRegularMessage; } }; when(dataType.getUUID()).thenReturn(uuid); final FlashMessage flashMessage = errorMessage.getFlashMessage(dataType); final FlashMessage.Type actualType = flashMessage.getType(); final String actualStrongMessage = flashMessage.getStrongMessage(); final String actualRegularMessage = flashMessage.getRegularMessage(); final String actualErrorElementSelector = flashMessage.getElementSelector(); assertEquals(expectedType, actualType); assertEquals(expectedStrongMessage, actualStrongMessage); assertEquals(expectedRegularMessage, actualRegularMessage); assertEquals(expectedErrorElementSelector, actualErrorElementSelector); } |
### Question:
DataTypeNameIsInvalidErrorMessage extends ErrorMessage { @Override String getStrongMessage(final DataType dataType) { return translationService.format(DataTypeNameIsInvalidErrorMessage_StrongMessage); } @Inject DataTypeNameIsInvalidErrorMessage(final TranslationService translationService); }### Answer:
@Test public void testGetStrongMessage() { final DataType dataType = mock(DataType.class); final String expectedErrorMessage = "*Expected strong message.*"; final DataTypeNameIsInvalidErrorMessage errorMessage = new DataTypeNameIsInvalidErrorMessage(translationService); when(translationService.format(DataTypeNameIsInvalidErrorMessage_StrongMessage)).thenReturn(expectedErrorMessage); final String actualErrorMessage = errorMessage.getStrongMessage(dataType); assertEquals(expectedErrorMessage, actualErrorMessage); } |
### Question:
DataTypeNameIsInvalidErrorMessage extends ErrorMessage { @Override String getRegularMessage() { return translationService.format(DataTypeNameIsInvalidErrorMessage_RegularMessage); } @Inject DataTypeNameIsInvalidErrorMessage(final TranslationService translationService); }### Answer:
@Test public void testGetRegularMessage() { final String expectedErrorMessage = "Expected regular message."; final DataTypeNameIsInvalidErrorMessage errorMessage = new DataTypeNameIsInvalidErrorMessage(translationService); when(translationService.format(DataTypeNameIsInvalidErrorMessage_RegularMessage)).thenReturn(expectedErrorMessage); final String actualErrorMessage = errorMessage.getRegularMessage(); assertEquals(expectedErrorMessage, actualErrorMessage); } |
### Question:
DataTypeNameIsBlankErrorMessage extends ErrorMessage { @Override String getStrongMessage(final DataType dataType) { return translationService.format(DataTypeNameIsBlankErrorMessage_StrongMessage); } @Inject DataTypeNameIsBlankErrorMessage(final TranslationService translationService); }### Answer:
@Test public void testGetStrongMessage() { final DataType dataType = mock(DataType.class); final String expectedErrorMessage = "*Expected strong message.*"; final DataTypeNameIsBlankErrorMessage errorMessage = new DataTypeNameIsBlankErrorMessage(translationService); when(translationService.format(DataTypeNameIsBlankErrorMessage_StrongMessage)).thenReturn(expectedErrorMessage); final String actualErrorMessage = errorMessage.getStrongMessage(dataType); assertEquals(expectedErrorMessage, actualErrorMessage); } |
### Question:
BindingPropertyConverter { public static org.kie.dmn.model.api.Binding dmnFromWB(final Binding wb, final Consumer<ComponentWidths> componentWidthsConsumer) { if (wb == null) { return null; } final org.kie.dmn.model.api.Binding result = new org.kie.dmn.model.v1_2.TBinding(); final org.kie.dmn.model.api.InformationItem convertedParameter = InformationItemPropertyConverter.dmnFromWB(wb.getParameter()); final org.kie.dmn.model.api.Expression convertedExpression = ExpressionPropertyConverter.dmnFromWB(wb.getExpression(), componentWidthsConsumer); if (convertedParameter != null) { convertedParameter.setParent(result); } result.setParameter(convertedParameter); if (convertedExpression != null) { convertedExpression.setParent(result); } result.setExpression(convertedExpression); return result; } static Binding wbFromDMN(final org.kie.dmn.model.api.Binding dmn,
final BiConsumer<String, HasComponentWidths> hasComponentWidthsConsumer); static org.kie.dmn.model.api.Binding dmnFromWB(final Binding wb,
final Consumer<ComponentWidths> componentWidthsConsumer); }### Answer:
@Test public void testDMNFromWB() { final Binding wb = new Binding(); final InformationItem informationItem = new InformationItem(); wb.setParameter(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.Binding dmn = BindingPropertyConverter.dmnFromWB(wb, componentWidthsConsumer); assertThat(dmn).isNotNull(); assertThat(dmn.getParameter()).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); } |
### Question:
DataTypeNameIsBlankErrorMessage extends ErrorMessage { @Override String getRegularMessage() { return translationService.format(DataTypeNameIsBlankErrorMessage_RegularMessage); } @Inject DataTypeNameIsBlankErrorMessage(final TranslationService translationService); }### Answer:
@Test public void testGetRegularMessage() { final String expectedErrorMessage = "Expected regular message."; final DataTypeNameIsBlankErrorMessage errorMessage = new DataTypeNameIsBlankErrorMessage(translationService); when(translationService.format(DataTypeNameIsBlankErrorMessage_RegularMessage)).thenReturn(expectedErrorMessage); final String actualErrorMessage = errorMessage.getRegularMessage(); assertEquals(expectedErrorMessage, actualErrorMessage); } |
### Question:
DataTypeNameIsNotUniqueErrorMessage extends ErrorMessage { @Override String getStrongMessage(final DataType dataType) { return translationService.format(DataTypeNameIsNotUniqueErrorMessage_StrongMessage, dataType.getName()); } @Inject DataTypeNameIsNotUniqueErrorMessage(final TranslationService translationService); }### Answer:
@Test public void testGetStrongMessage() { final DataType dataType = mock(DataType.class); final String dataTypeName = "name"; final String expectedErrorMessage = "*Expected strong message.*"; final DataTypeNameIsNotUniqueErrorMessage errorMessage = new DataTypeNameIsNotUniqueErrorMessage(translationService); when(dataType.getName()).thenReturn(dataTypeName); when(translationService.format(DataTypeNameIsNotUniqueErrorMessage_StrongMessage, dataTypeName)).thenReturn(expectedErrorMessage); final String actualErrorMessage = errorMessage.getStrongMessage(dataType); assertEquals(expectedErrorMessage, actualErrorMessage); } |
### Question:
DataTypeNameIsNotUniqueErrorMessage extends ErrorMessage { @Override String getRegularMessage() { return translationService.format(DataTypeNameIsNotUniqueErrorMessage_RegularMessage); } @Inject DataTypeNameIsNotUniqueErrorMessage(final TranslationService translationService); }### Answer:
@Test public void testGetRegularMessage() { final String expectedErrorMessage = "Expected regular message."; final DataTypeNameIsNotUniqueErrorMessage errorMessage = new DataTypeNameIsNotUniqueErrorMessage(translationService); when(translationService.format(DataTypeNameIsNotUniqueErrorMessage_RegularMessage)).thenReturn(expectedErrorMessage); final String actualErrorMessage = errorMessage.getRegularMessage(); assertEquals(expectedErrorMessage, actualErrorMessage); } |
### Question:
ScrollHelper { public void scrollToBottom(final Element element) { scrollTo(element, element); } void animatedScrollToBottom(final Element element); void scrollToBottom(final Element element); void scrollTo(final Element target,
final Element container,
final int padding); void scrollTo(final Element target,
final Element container); }### Answer:
@Test public void testScrollToBottom() { final Element element = mock(Element.class); doNothing().when(scrollHelper).scrollTo(element, element); scrollHelper.scrollToBottom(element); verify(scrollHelper).scrollTo(element, element); } |
### Question:
ScrollHelper { public void scrollTo(final Element target, final Element container, final int padding) { final double targetOffsetTop = ((HTMLElement) target).offsetTop; final double containerOffsetTop = ((HTMLElement) container).offsetTop; container.scrollTop = targetOffsetTop - containerOffsetTop - padding; } void animatedScrollToBottom(final Element element); void scrollToBottom(final Element element); void scrollTo(final Element target,
final Element container,
final int padding); void scrollTo(final Element target,
final Element container); }### Answer:
@Test public void testScrollToWithTwoArguments() { final Element target = mock(Element.class); final Element container = mock(Element.class); doNothing().when(scrollHelper).scrollTo(any(), any(), anyInt()); scrollHelper.scrollTo(target, container); verify(scrollHelper).scrollTo(target, container, 0); }
@Test public void testScrollToWithThreeArguments() { final HTMLElement target = mock(HTMLElement.class); final HTMLElement container = mock(HTMLElement.class); target.offsetTop = 8; container.offsetTop = 4; scrollHelper.scrollTo(target, container, 2); final Double expectedScrollTop = 2d; final Double actualScrollTop = container.scrollTop; assertEquals(expectedScrollTop, actualScrollTop); } |
### Question:
ScrollHelper { public void animatedScrollToBottom(final Element element) { animatedScrollToBottom(element, element.scrollHeight); } void animatedScrollToBottom(final Element element); void scrollToBottom(final Element element); void scrollTo(final Element target,
final Element container,
final int padding); void scrollTo(final Element target,
final Element container); }### Answer:
@Test public void testAnimatedScrollToBottomWithOneArgument() { final Element element = mock(Element.class); final int scrollHeight = 123; element.scrollHeight = scrollHeight; doNothing().when(scrollHelper).animatedScrollToBottom(any(), anyDouble()); scrollHelper.animatedScrollToBottom(element); verify(scrollHelper).animatedScrollToBottom(element, scrollHeight); } |
### Question:
DataTypeUtils { public List<DataType> defaultDataTypes() { return Stream .of(BuiltInType.values()) .filter(builtInType -> !builtInType.equals(BuiltInType.UNDEFINED)) .map(bit -> dataTypeManager.from(bit).get()) .sorted(Comparator.comparing(DataType::getType)) .collect(toList()); } @Inject DataTypeUtils(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); DataType getTopLevelParent(final DataType dataType); List<DataType> defaultDataTypes(); List<DataType> customDataTypes(); }### Answer:
@Test public void testDefaultDataTypes() { final List<DataType> dataTypes = utils.defaultDataTypes(); assertEquals(10, dataTypes.size()); assertEquals("Any", dataTypes.get(0).getType()); assertEquals("boolean", dataTypes.get(1).getType()); assertEquals("context", dataTypes.get(2).getType()); assertEquals("date", dataTypes.get(3).getType()); assertEquals("date and time", dataTypes.get(4).getType()); assertEquals("days and time duration", dataTypes.get(5).getType()); assertEquals("number", dataTypes.get(6).getType()); assertEquals("string", dataTypes.get(7).getType()); assertEquals("time", dataTypes.get(8).getType()); assertEquals("years and months duration", dataTypes.get(9).getType()); } |
### Question:
DataTypeUtils { public List<DataType> customDataTypes() { return dataTypeStore .getTopLevelDataTypes() .stream() .sorted(Comparator.comparing(DataType::getName)) .collect(Collectors.toList()); } @Inject DataTypeUtils(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); DataType getTopLevelParent(final DataType dataType); List<DataType> defaultDataTypes(); List<DataType> customDataTypes(); }### Answer:
@Test public void testCustomDataTypes() { final DataType dataType1 = mock(DataType.class); final DataType dataType2 = mock(DataType.class); final List<DataType> unorderedDataTypes = asList(dataType1, dataType2); final List<DataType> expectedDataTypes = asList(dataType2, dataType1); when(dataTypeStore.getTopLevelDataTypes()).thenReturn(unorderedDataTypes); when(dataType1.getName()).thenReturn("z"); when(dataType2.getName()).thenReturn("a"); final List<DataType> actualDataTypes = utils.customDataTypes(); assertEquals(expectedDataTypes, actualDataTypes); } |
### Question:
DataTypeUtils { public DataType getTopLevelParent(final DataType dataType) { final String parentUUID = dataType.getParentUUID(); final Optional<DataType> parent = Optional.ofNullable(dataTypeStore.get(parentUUID)); return parent.map(this::getTopLevelParent).orElse(dataType); } @Inject DataTypeUtils(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); DataType getTopLevelParent(final DataType dataType); List<DataType> defaultDataTypes(); List<DataType> customDataTypes(); }### Answer:
@Test public void testGetTopLevelParent() { final DataType dataType1 = mock(DataType.class); final DataType dataType2 = mock(DataType.class); final DataType dataType3 = mock(DataType.class); final String uuid1 = "0000"; final String uuid2 = "1111"; final String uuid3 = "2222"; when(dataType1.getUUID()).thenReturn(uuid1); when(dataType2.getUUID()).thenReturn(uuid2); when(dataType3.getUUID()).thenReturn(uuid3); when(dataType1.getParentUUID()).thenReturn(""); when(dataType2.getParentUUID()).thenReturn(uuid1); when(dataType3.getParentUUID()).thenReturn(uuid2); when(dataTypeStore.get(uuid1)).thenReturn(dataType1); when(dataTypeStore.get(uuid2)).thenReturn(dataType2); when(dataTypeStore.get(uuid3)).thenReturn(dataType3); final DataType topLevelParent = utils.getTopLevelParent(dataType3); assertEquals(dataType1, topLevelParent); } |
### Question:
ExpressionLanguagePropertyConverter { public static ExpressionLanguage wbFromDMN(final String language) { if (language == null) { return new ExpressionLanguage(""); } else { return new ExpressionLanguage(language); } } static ExpressionLanguage wbFromDMN(final String language); static String dmnFromWB(final ExpressionLanguage language); }### Answer:
@Test public void testWBFromDMNWithNullValue() { assertEquals("", ExpressionLanguagePropertyConverter.wbFromDMN(null).getValue()); }
@Test public void testWBFromDMNWithNonNullValue() { assertEquals(EXPRESSION_LANGUAGE, ExpressionLanguagePropertyConverter.wbFromDMN(EXPRESSION_LANGUAGE).getValue()); } |
### Question:
DataTypeManager { public DataTypeManager withConstraintType(final String constraintType) { dataType.setConstraintType(ConstraintType.fromString(constraintType)); return this; } @Inject DataTypeManager(final TranslationService translationService,
final ItemDefinitionRecordEngine recordEngine,
final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final ItemDefinitionUtils itemDefinitionUtils,
final ManagedInstance<DataTypeManager> dataTypeManagers,
final DataTypeNameValidator dataTypeNameValidator,
final DataTypeManagerStackStore typeStack); DataTypeManager fromNew(); DataTypeManager from(final ItemDefinition itemDefinition); DataTypeManager from(final BuiltInType builtInType); DataTypeManager from(final DataType dataType); DataTypeManager withParentUUID(final String parentUUID); DataTypeManager withName(final String name); DataTypeManager withType(final String type); DataTypeManager withConstraint(final String constraint); DataTypeManager withConstraintType(final String constraintType); DataTypeManager asList(final boolean isCollection); DataTypeManager withNoConstraint(); DataTypeManager withDataType(final DataType dataType); DataTypeManager withItemDefinition(final ItemDefinition itemDefinition); DataTypeManager withRefreshedSubDataTypes(final String newType); DataTypeManager withSubDataTypes(final List<DataType> dataTypes); DataTypeManager withNoName(); DataTypeManager withUniqueName(); DataTypeManager withUniqueName(final String name); DataTypeManager withItemDefinitionSubDataTypes(); DataTypeManager withIndexedItemDefinition(); DataType get(); List<DataType> makeExternalDataTypes(final String typeName); String structure(); String getTypeName(); DataTypeManager asStructure(); Optional<DataType> getTopLevelDataTypeWithName(final String typeName); }### Answer:
@Test public void testWithConstraintType() { final ConstraintType expectedConstraintType = ConstraintType.ENUMERATION; final DataType dataType = manager.from(makeDataType("uuid")).withConstraintType(expectedConstraintType.value()).get(); final ConstraintType actualConstraintType = dataType.getConstraintType(); assertEquals(expectedConstraintType, actualConstraintType); } |
### Question:
DataTypeManager { public DataTypeManager withParentUUID(final String parentUUID) { dataType.setParentUUID(parentUUID); return this; } @Inject DataTypeManager(final TranslationService translationService,
final ItemDefinitionRecordEngine recordEngine,
final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final ItemDefinitionUtils itemDefinitionUtils,
final ManagedInstance<DataTypeManager> dataTypeManagers,
final DataTypeNameValidator dataTypeNameValidator,
final DataTypeManagerStackStore typeStack); DataTypeManager fromNew(); DataTypeManager from(final ItemDefinition itemDefinition); DataTypeManager from(final BuiltInType builtInType); DataTypeManager from(final DataType dataType); DataTypeManager withParentUUID(final String parentUUID); DataTypeManager withName(final String name); DataTypeManager withType(final String type); DataTypeManager withConstraint(final String constraint); DataTypeManager withConstraintType(final String constraintType); DataTypeManager asList(final boolean isCollection); DataTypeManager withNoConstraint(); DataTypeManager withDataType(final DataType dataType); DataTypeManager withItemDefinition(final ItemDefinition itemDefinition); DataTypeManager withRefreshedSubDataTypes(final String newType); DataTypeManager withSubDataTypes(final List<DataType> dataTypes); DataTypeManager withNoName(); DataTypeManager withUniqueName(); DataTypeManager withUniqueName(final String name); DataTypeManager withItemDefinitionSubDataTypes(); DataTypeManager withIndexedItemDefinition(); DataType get(); List<DataType> makeExternalDataTypes(final String typeName); String structure(); String getTypeName(); DataTypeManager asStructure(); Optional<DataType> getTopLevelDataTypeWithName(final String typeName); }### Answer:
@Test public void testWithParentUUID() { final String expectedParentUUID = "expectedParentUUID"; final DataType dataType = manager.from(makeDataType("uuid")).withParentUUID(expectedParentUUID).get(); final String actualParentUUID = dataType.getParentUUID(); assertEquals(expectedParentUUID, actualParentUUID); } |
### Question:
DataTypeManager { public DataTypeManager withName(final String name) { dataType.setName(name); return this; } @Inject DataTypeManager(final TranslationService translationService,
final ItemDefinitionRecordEngine recordEngine,
final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final ItemDefinitionUtils itemDefinitionUtils,
final ManagedInstance<DataTypeManager> dataTypeManagers,
final DataTypeNameValidator dataTypeNameValidator,
final DataTypeManagerStackStore typeStack); DataTypeManager fromNew(); DataTypeManager from(final ItemDefinition itemDefinition); DataTypeManager from(final BuiltInType builtInType); DataTypeManager from(final DataType dataType); DataTypeManager withParentUUID(final String parentUUID); DataTypeManager withName(final String name); DataTypeManager withType(final String type); DataTypeManager withConstraint(final String constraint); DataTypeManager withConstraintType(final String constraintType); DataTypeManager asList(final boolean isCollection); DataTypeManager withNoConstraint(); DataTypeManager withDataType(final DataType dataType); DataTypeManager withItemDefinition(final ItemDefinition itemDefinition); DataTypeManager withRefreshedSubDataTypes(final String newType); DataTypeManager withSubDataTypes(final List<DataType> dataTypes); DataTypeManager withNoName(); DataTypeManager withUniqueName(); DataTypeManager withUniqueName(final String name); DataTypeManager withItemDefinitionSubDataTypes(); DataTypeManager withIndexedItemDefinition(); DataType get(); List<DataType> makeExternalDataTypes(final String typeName); String structure(); String getTypeName(); DataTypeManager asStructure(); Optional<DataType> getTopLevelDataTypeWithName(final String typeName); }### Answer:
@Test public void testWithName() { final String expectedName = "expectedName"; final DataType dataType = manager.from(makeDataType("uuid")).withName(expectedName).get(); final String actualName = dataType.getName(); assertEquals(expectedName, actualName); } |
### Question:
DataTypeManager { public DataTypeManager withNoName() { return withName(none()); } @Inject DataTypeManager(final TranslationService translationService,
final ItemDefinitionRecordEngine recordEngine,
final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final ItemDefinitionUtils itemDefinitionUtils,
final ManagedInstance<DataTypeManager> dataTypeManagers,
final DataTypeNameValidator dataTypeNameValidator,
final DataTypeManagerStackStore typeStack); DataTypeManager fromNew(); DataTypeManager from(final ItemDefinition itemDefinition); DataTypeManager from(final BuiltInType builtInType); DataTypeManager from(final DataType dataType); DataTypeManager withParentUUID(final String parentUUID); DataTypeManager withName(final String name); DataTypeManager withType(final String type); DataTypeManager withConstraint(final String constraint); DataTypeManager withConstraintType(final String constraintType); DataTypeManager asList(final boolean isCollection); DataTypeManager withNoConstraint(); DataTypeManager withDataType(final DataType dataType); DataTypeManager withItemDefinition(final ItemDefinition itemDefinition); DataTypeManager withRefreshedSubDataTypes(final String newType); DataTypeManager withSubDataTypes(final List<DataType> dataTypes); DataTypeManager withNoName(); DataTypeManager withUniqueName(); DataTypeManager withUniqueName(final String name); DataTypeManager withItemDefinitionSubDataTypes(); DataTypeManager withIndexedItemDefinition(); DataType get(); List<DataType> makeExternalDataTypes(final String typeName); String structure(); String getTypeName(); DataTypeManager asStructure(); Optional<DataType> getTopLevelDataTypeWithName(final String typeName); }### Answer:
@Test public void testWithNoName() { final String expectedName = NONE; final DataType dataType = manager.from(makeDataType("uuid")).withNoName().get(); final String actualName = dataType.getName(); assertEquals(expectedName, actualName); } |
### Question:
DataTypeManager { public DataTypeManager withType(final String type) { dataType.setType(type); return this; } @Inject DataTypeManager(final TranslationService translationService,
final ItemDefinitionRecordEngine recordEngine,
final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final ItemDefinitionUtils itemDefinitionUtils,
final ManagedInstance<DataTypeManager> dataTypeManagers,
final DataTypeNameValidator dataTypeNameValidator,
final DataTypeManagerStackStore typeStack); DataTypeManager fromNew(); DataTypeManager from(final ItemDefinition itemDefinition); DataTypeManager from(final BuiltInType builtInType); DataTypeManager from(final DataType dataType); DataTypeManager withParentUUID(final String parentUUID); DataTypeManager withName(final String name); DataTypeManager withType(final String type); DataTypeManager withConstraint(final String constraint); DataTypeManager withConstraintType(final String constraintType); DataTypeManager asList(final boolean isCollection); DataTypeManager withNoConstraint(); DataTypeManager withDataType(final DataType dataType); DataTypeManager withItemDefinition(final ItemDefinition itemDefinition); DataTypeManager withRefreshedSubDataTypes(final String newType); DataTypeManager withSubDataTypes(final List<DataType> dataTypes); DataTypeManager withNoName(); DataTypeManager withUniqueName(); DataTypeManager withUniqueName(final String name); DataTypeManager withItemDefinitionSubDataTypes(); DataTypeManager withIndexedItemDefinition(); DataType get(); List<DataType> makeExternalDataTypes(final String typeName); String structure(); String getTypeName(); DataTypeManager asStructure(); Optional<DataType> getTopLevelDataTypeWithName(final String typeName); }### Answer:
@Test public void testWithType() { final String expectedType = "expectedType"; final DataType dataType = manager.from(makeDataType("uuid")).withType(expectedType).get(); final String actualType = dataType.getType(); assertEquals(expectedType, actualType); } |
### Question:
DataTypeManager { public DataTypeManager withRefreshedSubDataTypes(final String newType) { return withSubDataTypes(makeExternalDataTypes(newType)); } @Inject DataTypeManager(final TranslationService translationService,
final ItemDefinitionRecordEngine recordEngine,
final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final ItemDefinitionUtils itemDefinitionUtils,
final ManagedInstance<DataTypeManager> dataTypeManagers,
final DataTypeNameValidator dataTypeNameValidator,
final DataTypeManagerStackStore typeStack); DataTypeManager fromNew(); DataTypeManager from(final ItemDefinition itemDefinition); DataTypeManager from(final BuiltInType builtInType); DataTypeManager from(final DataType dataType); DataTypeManager withParentUUID(final String parentUUID); DataTypeManager withName(final String name); DataTypeManager withType(final String type); DataTypeManager withConstraint(final String constraint); DataTypeManager withConstraintType(final String constraintType); DataTypeManager asList(final boolean isCollection); DataTypeManager withNoConstraint(); DataTypeManager withDataType(final DataType dataType); DataTypeManager withItemDefinition(final ItemDefinition itemDefinition); DataTypeManager withRefreshedSubDataTypes(final String newType); DataTypeManager withSubDataTypes(final List<DataType> dataTypes); DataTypeManager withNoName(); DataTypeManager withUniqueName(); DataTypeManager withUniqueName(final String name); DataTypeManager withItemDefinitionSubDataTypes(); DataTypeManager withIndexedItemDefinition(); DataType get(); List<DataType> makeExternalDataTypes(final String typeName); String structure(); String getTypeName(); DataTypeManager asStructure(); Optional<DataType> getTopLevelDataTypeWithName(final String typeName); }### Answer:
@Test public void testWithRefreshedSubDataTypes() { final String newType = "newType"; final List<DataType> expectedDataTypes = asList(mock(DataType.class), mock(DataType.class)); doReturn(expectedDataTypes).when(manager).makeExternalDataTypes(newType); final DataType dataType = manager.from(makeDataType("uuid")).withRefreshedSubDataTypes(newType).get(); final List<DataType> actualDataTypes = dataType.getSubDataTypes(); assertEquals(expectedDataTypes, actualDataTypes); } |
### Question:
DataTypeManager { public DataTypeManager withSubDataTypes(final List<DataType> dataTypes) { if (!isReadOnly(dataType)) { dataType.getSubDataTypes().forEach(dataType -> { dataTypeStore.unIndex(dataType.getUUID()); itemDefinitionStore.unIndex(dataType.getUUID()); }); dataType.setSubDataTypes(dataTypes); } return this; } @Inject DataTypeManager(final TranslationService translationService,
final ItemDefinitionRecordEngine recordEngine,
final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final ItemDefinitionUtils itemDefinitionUtils,
final ManagedInstance<DataTypeManager> dataTypeManagers,
final DataTypeNameValidator dataTypeNameValidator,
final DataTypeManagerStackStore typeStack); DataTypeManager fromNew(); DataTypeManager from(final ItemDefinition itemDefinition); DataTypeManager from(final BuiltInType builtInType); DataTypeManager from(final DataType dataType); DataTypeManager withParentUUID(final String parentUUID); DataTypeManager withName(final String name); DataTypeManager withType(final String type); DataTypeManager withConstraint(final String constraint); DataTypeManager withConstraintType(final String constraintType); DataTypeManager asList(final boolean isCollection); DataTypeManager withNoConstraint(); DataTypeManager withDataType(final DataType dataType); DataTypeManager withItemDefinition(final ItemDefinition itemDefinition); DataTypeManager withRefreshedSubDataTypes(final String newType); DataTypeManager withSubDataTypes(final List<DataType> dataTypes); DataTypeManager withNoName(); DataTypeManager withUniqueName(); DataTypeManager withUniqueName(final String name); DataTypeManager withItemDefinitionSubDataTypes(); DataTypeManager withIndexedItemDefinition(); DataType get(); List<DataType> makeExternalDataTypes(final String typeName); String structure(); String getTypeName(); DataTypeManager asStructure(); Optional<DataType> getTopLevelDataTypeWithName(final String typeName); }### Answer:
@Test public void testWithSubDataTypes() { final DataType topLevelDataType = mock(DataType.class); final DataType subLevelDataType = mock(DataType.class); final String subLevelDataTypeUuid = "subUuid"; when(subLevelDataType.getUUID()).thenReturn(subLevelDataTypeUuid); final List<DataType> newSubDataTypes = singletonList(mock(DataType.class)); when(topLevelDataType.getSubDataTypes()).thenReturn(singletonList(subLevelDataType)); when(itemDefinitionUtils.findByName(anyString())).thenReturn(Optional.empty()); manager.withDataType(topLevelDataType); manager.withSubDataTypes(newSubDataTypes); verify(dataTypeStore).unIndex(subLevelDataTypeUuid); verify(itemDefinitionStore).unIndex(subLevelDataTypeUuid); verify(topLevelDataType).setSubDataTypes(newSubDataTypes); } |
### Question:
DataTypeManager { DataType createSubDataType(final ItemDefinition itemDefinition) { return anotherManager() .newDataType(getDataType().isReadOnly()) .withUUID() .withParentUUID(getDataTypeUUID().orElseThrow(() -> new UnsupportedOperationException("A parent data type must have an UUID."))) .withItemDefinition(itemDefinition) .withItemDefinitionName() .withItemDefinitionType() .withItemDefinitionConstraint() .withItemDefinitionCollection() .withTypeStack(getSubDataTypeStack()) .withItemDefinitionSubDataTypes() .withIndexedItemDefinition() .get(); } @Inject DataTypeManager(final TranslationService translationService,
final ItemDefinitionRecordEngine recordEngine,
final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final ItemDefinitionUtils itemDefinitionUtils,
final ManagedInstance<DataTypeManager> dataTypeManagers,
final DataTypeNameValidator dataTypeNameValidator,
final DataTypeManagerStackStore typeStack); DataTypeManager fromNew(); DataTypeManager from(final ItemDefinition itemDefinition); DataTypeManager from(final BuiltInType builtInType); DataTypeManager from(final DataType dataType); DataTypeManager withParentUUID(final String parentUUID); DataTypeManager withName(final String name); DataTypeManager withType(final String type); DataTypeManager withConstraint(final String constraint); DataTypeManager withConstraintType(final String constraintType); DataTypeManager asList(final boolean isCollection); DataTypeManager withNoConstraint(); DataTypeManager withDataType(final DataType dataType); DataTypeManager withItemDefinition(final ItemDefinition itemDefinition); DataTypeManager withRefreshedSubDataTypes(final String newType); DataTypeManager withSubDataTypes(final List<DataType> dataTypes); DataTypeManager withNoName(); DataTypeManager withUniqueName(); DataTypeManager withUniqueName(final String name); DataTypeManager withItemDefinitionSubDataTypes(); DataTypeManager withIndexedItemDefinition(); DataType get(); List<DataType> makeExternalDataTypes(final String typeName); String structure(); String getTypeName(); DataTypeManager asStructure(); Optional<DataType> getTopLevelDataTypeWithName(final String typeName); }### Answer:
@Test public void testCreateSubDataType() { final DataType expectedDataType = mock(DataType.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); final List<String> subDataTypeStack = singletonList("type"); final String expectedParentUUID = "expectedParentUUID"; doReturn(expectedDataType).when(manager).getDataType(); doReturn(manager).when(manager).anotherManager(); doReturn(manager).when(manager).newDataType(anyBoolean()); doReturn(manager).when(manager).withUUID(); doReturn(manager).when(manager).withParentUUID(anyString()); doReturn(manager).when(manager).withItemDefinition(any()); doReturn(manager).when(manager).withItemDefinition(any()); doReturn(manager).when(manager).withItemDefinitionName(); doReturn(manager).when(manager).withItemDefinitionType(); doReturn(manager).when(manager).withItemDefinitionConstraint(); doReturn(manager).when(manager).withItemDefinitionCollection(); doReturn(manager).when(manager).withTypeStack(any()); doReturn(manager).when(manager).withItemDefinitionSubDataTypes(); doReturn(manager).when(manager).withIndexedItemDefinition(); doReturn(subDataTypeStack).when(manager).getSubDataTypeStack(); doReturn(expectedDataType).when(manager).get(); when(expectedDataType.isReadOnly()).thenReturn(false); when(expectedDataType.getUUID()).thenReturn(expectedParentUUID); final DataType actualDataType = manager.createSubDataType(itemDefinition); final InOrder inOrder = Mockito.inOrder(manager); inOrder.verify(manager).newDataType(false); inOrder.verify(manager).withUUID(); inOrder.verify(manager).withParentUUID(expectedParentUUID); inOrder.verify(manager).withItemDefinition(itemDefinition); inOrder.verify(manager).withItemDefinitionName(); inOrder.verify(manager).withItemDefinitionType(); inOrder.verify(manager).withTypeStack(subDataTypeStack); inOrder.verify(manager).withItemDefinitionSubDataTypes(); inOrder.verify(manager).withIndexedItemDefinition(); assertEquals(expectedDataType, actualDataType); } |
### Question:
DataTypeManager { List<String> getSubDataTypeStack() { final List<String> subDataTypeStack = new ArrayList<>(getTypeStack()); getStackType().ifPresent(subDataTypeStack::add); return subDataTypeStack; } @Inject DataTypeManager(final TranslationService translationService,
final ItemDefinitionRecordEngine recordEngine,
final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final ItemDefinitionUtils itemDefinitionUtils,
final ManagedInstance<DataTypeManager> dataTypeManagers,
final DataTypeNameValidator dataTypeNameValidator,
final DataTypeManagerStackStore typeStack); DataTypeManager fromNew(); DataTypeManager from(final ItemDefinition itemDefinition); DataTypeManager from(final BuiltInType builtInType); DataTypeManager from(final DataType dataType); DataTypeManager withParentUUID(final String parentUUID); DataTypeManager withName(final String name); DataTypeManager withType(final String type); DataTypeManager withConstraint(final String constraint); DataTypeManager withConstraintType(final String constraintType); DataTypeManager asList(final boolean isCollection); DataTypeManager withNoConstraint(); DataTypeManager withDataType(final DataType dataType); DataTypeManager withItemDefinition(final ItemDefinition itemDefinition); DataTypeManager withRefreshedSubDataTypes(final String newType); DataTypeManager withSubDataTypes(final List<DataType> dataTypes); DataTypeManager withNoName(); DataTypeManager withUniqueName(); DataTypeManager withUniqueName(final String name); DataTypeManager withItemDefinitionSubDataTypes(); DataTypeManager withIndexedItemDefinition(); DataType get(); List<DataType> makeExternalDataTypes(final String typeName); String structure(); String getTypeName(); DataTypeManager asStructure(); Optional<DataType> getTopLevelDataTypeWithName(final String typeName); }### Answer:
@Test public void testGetSubDataTypeStack() { final DataType dataType = mock(DataType.class); final String uuid = "uuid"; when(typeStack.get(uuid)).thenReturn(asList("tPerson", "tCompany")); when(dataType.getUUID()).thenReturn(uuid); when(dataType.getType()).thenReturn("tCity"); doReturn(dataType).when(manager).getDataType(); final List<String> actualTypeStack = manager.getSubDataTypeStack(); final List<String> expectedTypeStack = asList("tPerson", "tCompany", "tCity"); assertEquals(expectedTypeStack, actualTypeStack); } |
### Question:
DataTypeManager { ItemDefinition getItemDefinitionWithItemComponent(final ItemDefinition itemDefinition) { if (itemDefinition.getTypeRef() != null) { final Optional<ItemDefinition> definition = findByName(itemDefinitionType(itemDefinition)); if (definition.isPresent()) { return getItemDefinitionWithItemComponent(definition.get()); } } return itemDefinition; } @Inject DataTypeManager(final TranslationService translationService,
final ItemDefinitionRecordEngine recordEngine,
final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final ItemDefinitionUtils itemDefinitionUtils,
final ManagedInstance<DataTypeManager> dataTypeManagers,
final DataTypeNameValidator dataTypeNameValidator,
final DataTypeManagerStackStore typeStack); DataTypeManager fromNew(); DataTypeManager from(final ItemDefinition itemDefinition); DataTypeManager from(final BuiltInType builtInType); DataTypeManager from(final DataType dataType); DataTypeManager withParentUUID(final String parentUUID); DataTypeManager withName(final String name); DataTypeManager withType(final String type); DataTypeManager withConstraint(final String constraint); DataTypeManager withConstraintType(final String constraintType); DataTypeManager asList(final boolean isCollection); DataTypeManager withNoConstraint(); DataTypeManager withDataType(final DataType dataType); DataTypeManager withItemDefinition(final ItemDefinition itemDefinition); DataTypeManager withRefreshedSubDataTypes(final String newType); DataTypeManager withSubDataTypes(final List<DataType> dataTypes); DataTypeManager withNoName(); DataTypeManager withUniqueName(); DataTypeManager withUniqueName(final String name); DataTypeManager withItemDefinitionSubDataTypes(); DataTypeManager withIndexedItemDefinition(); DataType get(); List<DataType> makeExternalDataTypes(final String typeName); String structure(); String getTypeName(); DataTypeManager asStructure(); Optional<DataType> getTopLevelDataTypeWithName(final String typeName); }### Answer:
@Test public void testGetItemDefinitionWithItemComponent() { final ItemDefinition expectedItemDefinition = mock(ItemDefinition.class); final ItemDefinition tPerson = mock(ItemDefinition.class); final QName tPersonQName = mock(QName.class); final String tPersonValue = "tPersonRaw"; when(tPerson.getTypeRef()).thenReturn(tPersonQName); when(tPersonQName.getLocalPart()).thenReturn(tPersonValue); when(itemDefinitionUtils.findByName(tPersonValue)).thenReturn(Optional.of(expectedItemDefinition)); final ItemDefinition actualItemDefinition = manager.getItemDefinitionWithItemComponent(tPerson); assertEquals(expectedItemDefinition, actualItemDefinition); } |
### Question:
DataTypeManager { public DataTypeManager asStructure() { return withType(structure()); } @Inject DataTypeManager(final TranslationService translationService,
final ItemDefinitionRecordEngine recordEngine,
final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final ItemDefinitionUtils itemDefinitionUtils,
final ManagedInstance<DataTypeManager> dataTypeManagers,
final DataTypeNameValidator dataTypeNameValidator,
final DataTypeManagerStackStore typeStack); DataTypeManager fromNew(); DataTypeManager from(final ItemDefinition itemDefinition); DataTypeManager from(final BuiltInType builtInType); DataTypeManager from(final DataType dataType); DataTypeManager withParentUUID(final String parentUUID); DataTypeManager withName(final String name); DataTypeManager withType(final String type); DataTypeManager withConstraint(final String constraint); DataTypeManager withConstraintType(final String constraintType); DataTypeManager asList(final boolean isCollection); DataTypeManager withNoConstraint(); DataTypeManager withDataType(final DataType dataType); DataTypeManager withItemDefinition(final ItemDefinition itemDefinition); DataTypeManager withRefreshedSubDataTypes(final String newType); DataTypeManager withSubDataTypes(final List<DataType> dataTypes); DataTypeManager withNoName(); DataTypeManager withUniqueName(); DataTypeManager withUniqueName(final String name); DataTypeManager withItemDefinitionSubDataTypes(); DataTypeManager withIndexedItemDefinition(); DataType get(); List<DataType> makeExternalDataTypes(final String typeName); String structure(); String getTypeName(); DataTypeManager asStructure(); Optional<DataType> getTopLevelDataTypeWithName(final String typeName); }### Answer:
@Test public void testAsStructure() { final DataType dataType = makeDataType("uuid"); manager.withDataType(dataType).asStructure(); verify(manager).withType(STRUCTURE); } |
### Question:
DataTypeManager { public Optional<DataType> getTopLevelDataTypeWithName(final String typeName) { return findTopLevelDataTypeWithName(typeName); } @Inject DataTypeManager(final TranslationService translationService,
final ItemDefinitionRecordEngine recordEngine,
final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final ItemDefinitionUtils itemDefinitionUtils,
final ManagedInstance<DataTypeManager> dataTypeManagers,
final DataTypeNameValidator dataTypeNameValidator,
final DataTypeManagerStackStore typeStack); DataTypeManager fromNew(); DataTypeManager from(final ItemDefinition itemDefinition); DataTypeManager from(final BuiltInType builtInType); DataTypeManager from(final DataType dataType); DataTypeManager withParentUUID(final String parentUUID); DataTypeManager withName(final String name); DataTypeManager withType(final String type); DataTypeManager withConstraint(final String constraint); DataTypeManager withConstraintType(final String constraintType); DataTypeManager asList(final boolean isCollection); DataTypeManager withNoConstraint(); DataTypeManager withDataType(final DataType dataType); DataTypeManager withItemDefinition(final ItemDefinition itemDefinition); DataTypeManager withRefreshedSubDataTypes(final String newType); DataTypeManager withSubDataTypes(final List<DataType> dataTypes); DataTypeManager withNoName(); DataTypeManager withUniqueName(); DataTypeManager withUniqueName(final String name); DataTypeManager withItemDefinitionSubDataTypes(); DataTypeManager withIndexedItemDefinition(); DataType get(); List<DataType> makeExternalDataTypes(final String typeName); String structure(); String getTypeName(); DataTypeManager asStructure(); Optional<DataType> getTopLevelDataTypeWithName(final String typeName); }### Answer:
@Test public void testGetTopLevelDataTypeWithName() { final String topLevelType = "tType"; final DataType dataType = mock(DataType.class); final Optional<DataType> type = Optional.of(dataType); doReturn(type).when(manager).findTopLevelDataTypeWithName(topLevelType); final Optional<DataType> actual = manager.getTopLevelDataTypeWithName(topLevelType); assertTrue(actual.isPresent()); assertEquals(dataType, actual.get()); } |
### Question:
DataTypeManager { Optional<DataType> findTopLevelDataTypeWithName(final String typeName) { return dataTypeStore.getTopLevelDataTypes().stream() .filter(data -> Objects.equals(data.getName(), typeName)) .findFirst(); } @Inject DataTypeManager(final TranslationService translationService,
final ItemDefinitionRecordEngine recordEngine,
final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final ItemDefinitionUtils itemDefinitionUtils,
final ManagedInstance<DataTypeManager> dataTypeManagers,
final DataTypeNameValidator dataTypeNameValidator,
final DataTypeManagerStackStore typeStack); DataTypeManager fromNew(); DataTypeManager from(final ItemDefinition itemDefinition); DataTypeManager from(final BuiltInType builtInType); DataTypeManager from(final DataType dataType); DataTypeManager withParentUUID(final String parentUUID); DataTypeManager withName(final String name); DataTypeManager withType(final String type); DataTypeManager withConstraint(final String constraint); DataTypeManager withConstraintType(final String constraintType); DataTypeManager asList(final boolean isCollection); DataTypeManager withNoConstraint(); DataTypeManager withDataType(final DataType dataType); DataTypeManager withItemDefinition(final ItemDefinition itemDefinition); DataTypeManager withRefreshedSubDataTypes(final String newType); DataTypeManager withSubDataTypes(final List<DataType> dataTypes); DataTypeManager withNoName(); DataTypeManager withUniqueName(); DataTypeManager withUniqueName(final String name); DataTypeManager withItemDefinitionSubDataTypes(); DataTypeManager withIndexedItemDefinition(); DataType get(); List<DataType> makeExternalDataTypes(final String typeName); String structure(); String getTypeName(); DataTypeManager asStructure(); Optional<DataType> getTopLevelDataTypeWithName(final String typeName); }### Answer:
@Test public void testFindTopLevelDataTypeWithName() { final DataType dt1 = mock(DataType.class); final String dt1Name = "The Name"; when(dt1.getName()).thenReturn(dt1Name); final DataType dt2 = mock(DataType.class); final String dt2Name = "The Other Name"; when(dt2.getName()).thenReturn(dt2Name); final List<DataType> store = Arrays.asList(dt1, dt2); when(dataTypeStore.getTopLevelDataTypes()).thenReturn(store); Optional<DataType> foundDt = manager.findTopLevelDataTypeWithName(dt1Name); assertTrue(foundDt.isPresent()); assertEquals(dt1, foundDt.get()); foundDt = manager.findTopLevelDataTypeWithName(dt2Name); assertTrue(foundDt.isPresent()); assertEquals(dt2, foundDt.get()); Optional<DataType> notFoundDt = manager.findTopLevelDataTypeWithName("not present"); assertFalse(notFoundDt.isPresent()); } |
### Question:
DataTypePickerWidget extends Composite implements HasValue<QName>,
HasEnabled { @Override public void setValue(final QName value) { setValue(value, false); } DataTypePickerWidget(); @Inject DataTypePickerWidget(final Anchor typeButton,
final Div manageContainer,
final Span manageLabel,
final TranslationService translationService,
final QNameConverter qNameConverter,
final DMNGraphUtils dmnGraphUtils,
final Event<DataTypePageTabActiveEvent> dataTypePageActiveEvent,
final ItemDefinitionUtils itemDefinitionUtils,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @PostConstruct void init(); void setDMNModel(final DMNModelInstrumentedBase dmnModel); @SuppressWarnings("unused") void onDataTypePageNavTabActiveEvent(final @Observes DataTypeChangedEvent event); @EventHandler("typeButton") @SuppressWarnings("unused") void onClickTypeButton(final ClickEvent clickEvent); void showManageLabel(); void hideManageLabel(); @Override QName getValue(); @Override void setValue(final QName value); @Override void setValue(final QName value,
final boolean fireEvents); @Override HandlerRegistration addValueChangeHandler(final ValueChangeHandler<QName> handler); @Override boolean isEnabled(); @Override void setEnabled(final boolean enabled); }### Answer:
@Test public void testSetValue() { picker.setValue(VALUE); verify(typeSelector).setValue(eq(WIDGET_VALUE), eq(false)); verify(picker, never()).fireValueChangeEvent(any()); } |
### Question:
DataTypePickerWidget extends Composite implements HasValue<QName>,
HasEnabled { @Override public QName getValue() { return type; } DataTypePickerWidget(); @Inject DataTypePickerWidget(final Anchor typeButton,
final Div manageContainer,
final Span manageLabel,
final TranslationService translationService,
final QNameConverter qNameConverter,
final DMNGraphUtils dmnGraphUtils,
final Event<DataTypePageTabActiveEvent> dataTypePageActiveEvent,
final ItemDefinitionUtils itemDefinitionUtils,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @PostConstruct void init(); void setDMNModel(final DMNModelInstrumentedBase dmnModel); @SuppressWarnings("unused") void onDataTypePageNavTabActiveEvent(final @Observes DataTypeChangedEvent event); @EventHandler("typeButton") @SuppressWarnings("unused") void onClickTypeButton(final ClickEvent clickEvent); void showManageLabel(); void hideManageLabel(); @Override QName getValue(); @Override void setValue(final QName value); @Override void setValue(final QName value,
final boolean fireEvents); @Override HandlerRegistration addValueChangeHandler(final ValueChangeHandler<QName> handler); @Override boolean isEnabled(); @Override void setEnabled(final boolean enabled); }### Answer:
@Test public void testGetValue() { picker.setValue(VALUE); assertEquals(VALUE, picker.getValue()); } |
### Question:
DataTypePickerWidget extends Composite implements HasValue<QName>,
HasEnabled { @EventHandler("typeButton") @SuppressWarnings("unused") public void onClickTypeButton(final ClickEvent clickEvent) { dataTypePageActiveEvent.fire(new DataTypePageTabActiveEvent()); } DataTypePickerWidget(); @Inject DataTypePickerWidget(final Anchor typeButton,
final Div manageContainer,
final Span manageLabel,
final TranslationService translationService,
final QNameConverter qNameConverter,
final DMNGraphUtils dmnGraphUtils,
final Event<DataTypePageTabActiveEvent> dataTypePageActiveEvent,
final ItemDefinitionUtils itemDefinitionUtils,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @PostConstruct void init(); void setDMNModel(final DMNModelInstrumentedBase dmnModel); @SuppressWarnings("unused") void onDataTypePageNavTabActiveEvent(final @Observes DataTypeChangedEvent event); @EventHandler("typeButton") @SuppressWarnings("unused") void onClickTypeButton(final ClickEvent clickEvent); void showManageLabel(); void hideManageLabel(); @Override QName getValue(); @Override void setValue(final QName value); @Override void setValue(final QName value,
final boolean fireEvents); @Override HandlerRegistration addValueChangeHandler(final ValueChangeHandler<QName> handler); @Override boolean isEnabled(); @Override void setEnabled(final boolean enabled); }### Answer:
@Test public void testOnClickTypeButton() { final ClickEvent clickEvent = mock(ClickEvent.class); picker.onClickTypeButton(clickEvent); verify(dataTypePageActiveEvent).fire(any(DataTypePageTabActiveEvent.class)); } |
### Question:
DataTypePickerWidget extends Composite implements HasValue<QName>,
HasEnabled { public void showManageLabel() { manageContainer.getStyle().removeProperty(CSS_DISPLAY); } DataTypePickerWidget(); @Inject DataTypePickerWidget(final Anchor typeButton,
final Div manageContainer,
final Span manageLabel,
final TranslationService translationService,
final QNameConverter qNameConverter,
final DMNGraphUtils dmnGraphUtils,
final Event<DataTypePageTabActiveEvent> dataTypePageActiveEvent,
final ItemDefinitionUtils itemDefinitionUtils,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @PostConstruct void init(); void setDMNModel(final DMNModelInstrumentedBase dmnModel); @SuppressWarnings("unused") void onDataTypePageNavTabActiveEvent(final @Observes DataTypeChangedEvent event); @EventHandler("typeButton") @SuppressWarnings("unused") void onClickTypeButton(final ClickEvent clickEvent); void showManageLabel(); void hideManageLabel(); @Override QName getValue(); @Override void setValue(final QName value); @Override void setValue(final QName value,
final boolean fireEvents); @Override HandlerRegistration addValueChangeHandler(final ValueChangeHandler<QName> handler); @Override boolean isEnabled(); @Override void setEnabled(final boolean enabled); }### Answer:
@Test public void testShowManageLabel() { picker.showManageLabel(); verify(manageContainerStyle).removeProperty(eq(DataTypePickerWidget.CSS_DISPLAY)); } |
### Question:
DataTypePickerWidget extends Composite implements HasValue<QName>,
HasEnabled { public void hideManageLabel() { manageContainer.getStyle().setProperty(CSS_DISPLAY, CSS_DISPLAY_NONE); } DataTypePickerWidget(); @Inject DataTypePickerWidget(final Anchor typeButton,
final Div manageContainer,
final Span manageLabel,
final TranslationService translationService,
final QNameConverter qNameConverter,
final DMNGraphUtils dmnGraphUtils,
final Event<DataTypePageTabActiveEvent> dataTypePageActiveEvent,
final ItemDefinitionUtils itemDefinitionUtils,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @PostConstruct void init(); void setDMNModel(final DMNModelInstrumentedBase dmnModel); @SuppressWarnings("unused") void onDataTypePageNavTabActiveEvent(final @Observes DataTypeChangedEvent event); @EventHandler("typeButton") @SuppressWarnings("unused") void onClickTypeButton(final ClickEvent clickEvent); void showManageLabel(); void hideManageLabel(); @Override QName getValue(); @Override void setValue(final QName value); @Override void setValue(final QName value,
final boolean fireEvents); @Override HandlerRegistration addValueChangeHandler(final ValueChangeHandler<QName> handler); @Override boolean isEnabled(); @Override void setEnabled(final boolean enabled); }### Answer:
@Test public void testHideManageLabel() { picker.hideManageLabel(); verify(manageContainerStyle).setProperty(eq(DataTypePickerWidget.CSS_DISPLAY), eq(DataTypePickerWidget.CSS_DISPLAY_NONE)); } |
### Question:
DataTypePickerWidget extends Composite implements HasValue<QName>,
HasEnabled { QName normaliseBuiltInTypeTypeRef(final QName typeRef) { return itemDefinitionUtils.normaliseTypeRef(typeRef); } DataTypePickerWidget(); @Inject DataTypePickerWidget(final Anchor typeButton,
final Div manageContainer,
final Span manageLabel,
final TranslationService translationService,
final QNameConverter qNameConverter,
final DMNGraphUtils dmnGraphUtils,
final Event<DataTypePageTabActiveEvent> dataTypePageActiveEvent,
final ItemDefinitionUtils itemDefinitionUtils,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @PostConstruct void init(); void setDMNModel(final DMNModelInstrumentedBase dmnModel); @SuppressWarnings("unused") void onDataTypePageNavTabActiveEvent(final @Observes DataTypeChangedEvent event); @EventHandler("typeButton") @SuppressWarnings("unused") void onClickTypeButton(final ClickEvent clickEvent); void showManageLabel(); void hideManageLabel(); @Override QName getValue(); @Override void setValue(final QName value); @Override void setValue(final QName value,
final boolean fireEvents); @Override HandlerRegistration addValueChangeHandler(final ValueChangeHandler<QName> handler); @Override boolean isEnabled(); @Override void setEnabled(final boolean enabled); }### Answer:
@Test public void testNormaliseBuiltInTypeTypeRef() { final QName typeRef = mock(QName.class); final QName expectedTypeRef = mock(QName.class); doReturn(expectedTypeRef).when(itemDefinitionUtils).normaliseTypeRef(typeRef); final QName actualTypeRef = picker.normaliseBuiltInTypeTypeRef(typeRef); assertEquals(expectedTypeRef, actualTypeRef); } |
### Question:
DataTypePickerWidget extends Composite implements HasValue<QName>,
HasEnabled { void setTypeButtonCSSClass() { if (readOnlyProvider.isReadOnlyDiagram()) { typeButton.getClassList().add(READ_ONLY_CSS_CLASS); } else { typeButton.getClassList().remove(READ_ONLY_CSS_CLASS); } } DataTypePickerWidget(); @Inject DataTypePickerWidget(final Anchor typeButton,
final Div manageContainer,
final Span manageLabel,
final TranslationService translationService,
final QNameConverter qNameConverter,
final DMNGraphUtils dmnGraphUtils,
final Event<DataTypePageTabActiveEvent> dataTypePageActiveEvent,
final ItemDefinitionUtils itemDefinitionUtils,
final @DMNEditor ReadOnlyProvider readOnlyProvider); @PostConstruct void init(); void setDMNModel(final DMNModelInstrumentedBase dmnModel); @SuppressWarnings("unused") void onDataTypePageNavTabActiveEvent(final @Observes DataTypeChangedEvent event); @EventHandler("typeButton") @SuppressWarnings("unused") void onClickTypeButton(final ClickEvent clickEvent); void showManageLabel(); void hideManageLabel(); @Override QName getValue(); @Override void setValue(final QName value); @Override void setValue(final QName value,
final boolean fireEvents); @Override HandlerRegistration addValueChangeHandler(final ValueChangeHandler<QName> handler); @Override boolean isEnabled(); @Override void setEnabled(final boolean enabled); }### Answer:
@Test public void testSetTypeButtonCSSClassWhenIsReadOnlyDiagram() { when(readOnlyProvider.isReadOnlyDiagram()).thenReturn(true); picker.setTypeButtonCSSClass(); verify(typeButtonClassList).add(READ_ONLY_CSS_CLASS); verify(typeButtonClassList, never()).remove(READ_ONLY_CSS_CLASS); }
@Test public void testSetTypeButtonCSSClassWhenIsNotReadOnlyDiagram() { when(readOnlyProvider.isReadOnlyDiagram()).thenReturn(false); picker.setTypeButtonCSSClass(); verify(typeButtonClassList, never()).add(READ_ONLY_CSS_CLASS); verify(typeButtonClassList).remove(READ_ONLY_CSS_CLASS); } |
### Question:
ExpressionLanguagePropertyConverter { public static String dmnFromWB(final ExpressionLanguage language) { if (language == null) { return null; } else if (StringUtils.isEmpty(language.getValue())) { return null; } else { return language.getValue(); } } static ExpressionLanguage wbFromDMN(final String language); static String dmnFromWB(final ExpressionLanguage language); }### Answer:
@Test public void testDMNFromWBWithNull() { assertNull(ExpressionLanguagePropertyConverter.dmnFromWB(null)); }
@Test public void testDMNFromWBWithNullValue() { assertNull(ExpressionLanguagePropertyConverter.dmnFromWB(new ExpressionLanguage(null))); }
@Test public void testDMNFromWBWithEmptyValue() { assertNull(ExpressionLanguagePropertyConverter.dmnFromWB(new ExpressionLanguage())); }
@Test public void testDMNFromWBWithNonNullValue() { assertEquals(EXPRESSION_LANGUAGE, ExpressionLanguagePropertyConverter.dmnFromWB(new ExpressionLanguage(EXPRESSION_LANGUAGE))); } |
### Question:
ValueAndDataTypePopoverImpl implements ValueAndDataTypePopoverView.Presenter { @Override public void show() { binding.ifPresent(b -> view.show(Optional.ofNullable(getPopoverTitle()))); } ValueAndDataTypePopoverImpl(); @Inject ValueAndDataTypePopoverImpl(final ValueAndDataTypePopoverView view); @Override HTMLElement getElement(); @Override String getPopoverTitle(); @Override void bind(final HasValueAndTypeRef bound,
final int uiRowIndex,
final int uiColumnIndex); @Override @SuppressWarnings("unchecked") void setValue(final String value); @Override void setTypeRef(final QName typeRef); @Override String getValueLabel(); @Override String normaliseValue(final String value); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); }### Answer:
@Test public void testShow() { editor.bind(bound, 0, 0); editor.show(); verify(view).show(Optional.empty()); } |
### Question:
ValueAndDataTypePopoverImpl implements ValueAndDataTypePopoverView.Presenter { @Override public void hide() { binding.ifPresent(b -> view.hide()); } ValueAndDataTypePopoverImpl(); @Inject ValueAndDataTypePopoverImpl(final ValueAndDataTypePopoverView view); @Override HTMLElement getElement(); @Override String getPopoverTitle(); @Override void bind(final HasValueAndTypeRef bound,
final int uiRowIndex,
final int uiColumnIndex); @Override @SuppressWarnings("unchecked") void setValue(final String value); @Override void setTypeRef(final QName typeRef); @Override String getValueLabel(); @Override String normaliseValue(final String value); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); }### Answer:
@Test public void testHide() { editor.bind(bound, 0, 0); editor.hide(); verify(view).hide(); } |
### Question:
ValueAndDataTypePopoverImpl implements ValueAndDataTypePopoverView.Presenter { @Override public void bind(final HasValueAndTypeRef bound, final int uiRowIndex, final int uiColumnIndex) { binding = Optional.ofNullable(bound); refresh(); } ValueAndDataTypePopoverImpl(); @Inject ValueAndDataTypePopoverImpl(final ValueAndDataTypePopoverView view); @Override HTMLElement getElement(); @Override String getPopoverTitle(); @Override void bind(final HasValueAndTypeRef bound,
final int uiRowIndex,
final int uiColumnIndex); @Override @SuppressWarnings("unchecked") void setValue(final String value); @Override void setTypeRef(final QName typeRef); @Override String getValueLabel(); @Override String normaliseValue(final String value); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); }### Answer:
@Test public void testBind() { editor.bind(bound, 0, 0); verify(view).setDMNModel(eq(decision)); verify(view).initValue(eq(NAME)); verify(view).initSelectedTypeRef(eq(typeRef)); editor.show(); verify(view).show(Optional.empty()); } |
### Question:
ValueAndDataTypePopoverImpl implements ValueAndDataTypePopoverView.Presenter { @Override public void setTypeRef(final QName typeRef) { binding.ifPresent(b -> b.setTypeRef(typeRef)); } ValueAndDataTypePopoverImpl(); @Inject ValueAndDataTypePopoverImpl(final ValueAndDataTypePopoverView view); @Override HTMLElement getElement(); @Override String getPopoverTitle(); @Override void bind(final HasValueAndTypeRef bound,
final int uiRowIndex,
final int uiColumnIndex); @Override @SuppressWarnings("unchecked") void setValue(final String value); @Override void setTypeRef(final QName typeRef); @Override String getValueLabel(); @Override String normaliseValue(final String value); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); }### Answer:
@Test public void testSetTypeRef() { editor.bind(bound, 0, 0); editor.setTypeRef(typeRef); verify(bound).setTypeRef(eq(typeRef)); } |
### Question:
ValueAndDataTypePopoverImpl implements ValueAndDataTypePopoverView.Presenter { @Override public void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback) { binding.ifPresent(b -> view.setOnClosedByKeyboardCallback(callback)); } ValueAndDataTypePopoverImpl(); @Inject ValueAndDataTypePopoverImpl(final ValueAndDataTypePopoverView view); @Override HTMLElement getElement(); @Override String getPopoverTitle(); @Override void bind(final HasValueAndTypeRef bound,
final int uiRowIndex,
final int uiColumnIndex); @Override @SuppressWarnings("unchecked") void setValue(final String value); @Override void setTypeRef(final QName typeRef); @Override String getValueLabel(); @Override String normaliseValue(final String value); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); }### Answer:
@Test @SuppressWarnings("unchecked") public void testSetOnClosedByKeyboardCallback_WhenNotBound() { final Consumer callback = mock(Consumer.class); editor.setOnClosedByKeyboardCallback(callback); verify(view, never()).setOnClosedByKeyboardCallback(any(Consumer.class)); } |
### Question:
ValueAndDataTypePopoverImpl implements ValueAndDataTypePopoverView.Presenter { @Override public String getValueLabel() { return binding.orElseThrow(() -> new IllegalStateException(BINDING_EXCEPTION)).getValueLabel(); } ValueAndDataTypePopoverImpl(); @Inject ValueAndDataTypePopoverImpl(final ValueAndDataTypePopoverView view); @Override HTMLElement getElement(); @Override String getPopoverTitle(); @Override void bind(final HasValueAndTypeRef bound,
final int uiRowIndex,
final int uiColumnIndex); @Override @SuppressWarnings("unchecked") void setValue(final String value); @Override void setTypeRef(final QName typeRef); @Override String getValueLabel(); @Override String normaliseValue(final String value); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); }### Answer:
@Test public void testGetValueLabel_WhenNotBound() { final Throwable thrown = catchThrowable(() -> editor.getValueLabel()); assertThat(thrown).isInstanceOf(IllegalStateException.class) .hasMessageContaining(BINDING_EXCEPTION); } |
### Question:
ValueAndDataTypePopoverImpl implements ValueAndDataTypePopoverView.Presenter { @Override public String normaliseValue(final String value) { return binding.orElseThrow(() -> new IllegalStateException(BINDING_EXCEPTION)).normaliseValue(value); } ValueAndDataTypePopoverImpl(); @Inject ValueAndDataTypePopoverImpl(final ValueAndDataTypePopoverView view); @Override HTMLElement getElement(); @Override String getPopoverTitle(); @Override void bind(final HasValueAndTypeRef bound,
final int uiRowIndex,
final int uiColumnIndex); @Override @SuppressWarnings("unchecked") void setValue(final String value); @Override void setTypeRef(final QName typeRef); @Override String getValueLabel(); @Override String normaliseValue(final String value); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); }### Answer:
@Test public void testNormaliseValue_WhenNotBound() { final Throwable thrown = catchThrowable(() -> editor.normaliseValue(NAME)); assertThat(thrown).isInstanceOf(IllegalStateException.class) .hasMessageContaining(BINDING_EXCEPTION); } |
### Question:
DataTypeNameValidator { public boolean isValid(final DataType dataType) { if (isBlank(dataType)) { flashMessageEvent.fire(blankErrorMessage.getFlashMessage(dataType)); return false; } if (isNotUnique(dataType)) { flashMessageEvent.fire(notUniqueErrorMessage.getFlashMessage(dataType)); return false; } if (isDefault(dataType)) { flashMessageEvent.fire(nameIsDefaultTypeMessage.getFlashMessage(dataType)); return false; } return true; } @Inject DataTypeNameValidator(final Event<FlashMessage> flashMessageEvent,
final DataTypeNameIsBlankErrorMessage blankErrorMessage,
final DataTypeNameIsNotUniqueErrorMessage notUniqueErrorMessage,
final DataTypeNameIsDefaultTypeMessage nameIsDefaultTypeMessage,
final DataTypeStore dataTypeStore); boolean isValid(final DataType dataType); boolean isNotUnique(final DataType dataType); List<DataType> siblings(final DataType dataType); }### Answer:
@Test public void testIsValid() { final DataType dataType = mock(DataType.class); doReturn(false).when(validator).isBlank(dataType); doReturn(false).when(validator).isNotUnique(dataType); doReturn(false).when(validator).isDefault(dataType); final boolean isValid = validator.isValid(dataType); verify(flashMessageEvent, never()).fire(any()); verify(flashMessageEvent, never()).fire(any()); assertTrue(isValid); } |
### Question:
DataTypeNameValidator { boolean isBlank(final DataType dataType) { return isEmpty(dataType.getName()); } @Inject DataTypeNameValidator(final Event<FlashMessage> flashMessageEvent,
final DataTypeNameIsBlankErrorMessage blankErrorMessage,
final DataTypeNameIsNotUniqueErrorMessage notUniqueErrorMessage,
final DataTypeNameIsDefaultTypeMessage nameIsDefaultTypeMessage,
final DataTypeStore dataTypeStore); boolean isValid(final DataType dataType); boolean isNotUnique(final DataType dataType); List<DataType> siblings(final DataType dataType); }### Answer:
@Test public void testIsNotBlankWhenNameIsBlank() { final DataType dataType = makeDataType("uuid", ""); assertTrue(validator.isBlank(dataType)); }
@Test public void testIsNotBlankWhenNameIsNull() { final DataType dataType = makeDataType("uuid", null); assertTrue(validator.isBlank(dataType)); }
@Test public void testIsNotBlankWhenNameIsNotBlank() { final DataType dataType = makeDataType("uuid", "tCity"); assertFalse(validator.isBlank(dataType)); } |
### Question:
DataTypeNameValidator { boolean isDefault(final DataType dataType) { return BuiltInTypeUtils.isBuiltInType(dataType.getName()); } @Inject DataTypeNameValidator(final Event<FlashMessage> flashMessageEvent,
final DataTypeNameIsBlankErrorMessage blankErrorMessage,
final DataTypeNameIsNotUniqueErrorMessage notUniqueErrorMessage,
final DataTypeNameIsDefaultTypeMessage nameIsDefaultTypeMessage,
final DataTypeStore dataTypeStore); boolean isValid(final DataType dataType); boolean isNotUnique(final DataType dataType); List<DataType> siblings(final DataType dataType); }### Answer:
@Test public void testIsDefaultWhenItReturnsTrue() { final DataType dataType = mock(DataType.class); when(dataType.getName()).thenReturn("string"); assertTrue(validator.isDefault(dataType)); }
@Test public void testIsDefaultWhenItReturnsFalse() { final DataType dataType = mock(DataType.class); when(dataType.getName()).thenReturn("tCity"); assertFalse(validator.isDefault(dataType)); } |
### Question:
DataTypeNameValidator { public List<DataType> siblings(final DataType dataType) { final Optional<DataType> parent = Optional.ofNullable(dataTypeStore.get(dataType.getParentUUID())); if (parent.isPresent()) { return parent.get().getSubDataTypes(); } else { return dataTypeStore.getTopLevelDataTypes(); } } @Inject DataTypeNameValidator(final Event<FlashMessage> flashMessageEvent,
final DataTypeNameIsBlankErrorMessage blankErrorMessage,
final DataTypeNameIsNotUniqueErrorMessage notUniqueErrorMessage,
final DataTypeNameIsDefaultTypeMessage nameIsDefaultTypeMessage,
final DataTypeStore dataTypeStore); boolean isValid(final DataType dataType); boolean isNotUnique(final DataType dataType); List<DataType> siblings(final DataType dataType); }### Answer:
@Test public void testSiblingsWhenDataTypeDoesNotHaveParent() { final DataType dataType = mock(DataType.class); final List<DataType> expectedSiblings = Collections.singletonList(mock(DataType.class)); when(dataTypeStore.getTopLevelDataTypes()).thenReturn(expectedSiblings); final List<DataType> actualSiblings = validator.siblings(dataType); assertEquals(expectedSiblings, actualSiblings); }
@Test public void testSiblingsWhenDataTypeHasParent() { final DataType dataType = mock(DataType.class); final DataType parent = mock(DataType.class); final String parentUUID = "parentUUID"; final List<DataType> expectedSiblings = Collections.singletonList(mock(DataType.class)); when(dataType.getParentUUID()).thenReturn(parentUUID); when(parent.getSubDataTypes()).thenReturn(expectedSiblings); when(dataTypeStore.get(parentUUID)).thenReturn(parent); final List<DataType> actualSiblings = validator.siblings(dataType); assertEquals(expectedSiblings, actualSiblings); } |
### Question:
ItemDefinitionStore { public ItemDefinition get(final String uuid) { return itemDefinitions.get(uuid); } ItemDefinition get(final String uuid); void index(final String uuid,
final ItemDefinition itemDefinition); void clear(); void unIndex(final String uuid); }### Answer:
@Test public void testGetWhenItReturnsNull() { assertNull(store.get("456")); }
@Test public void testGetWhenItDoesNotReturnNull() { assertNotNull(store.get(uuid)); assertEquals(itemDefinition, store.get(uuid)); } |
### Question:
ItemDefinitionStore { public void index(final String uuid, final ItemDefinition itemDefinition) { itemDefinitions.put(uuid, itemDefinition); } ItemDefinition get(final String uuid); void index(final String uuid,
final ItemDefinition itemDefinition); void clear(); void unIndex(final String uuid); }### Answer:
@Test public void testIndex() { final ItemDefinition itemDefinition = mock(ItemDefinition.class); final String uuid = "789"; store.index(uuid, itemDefinition); assertEquals(itemDefinition, store.get(uuid)); } |
### Question:
ItemDefinitionStore { public void clear() { itemDefinitions.clear(); } ItemDefinition get(final String uuid); void index(final String uuid,
final ItemDefinition itemDefinition); void clear(); void unIndex(final String uuid); }### Answer:
@Test public void testClear() { store.clear(); assertEquals(0, store.size()); } |
### Question:
ItemDefinitionStore { public void unIndex(final String uuid) { itemDefinitions.remove(uuid); } ItemDefinition get(final String uuid); void index(final String uuid,
final ItemDefinition itemDefinition); void clear(); void unIndex(final String uuid); }### Answer:
@Test public void testUnIndex() { store.unIndex(uuid); assertNull(store.get(uuid)); } |
### Question:
ItemDefinitionUpdateHandler { Name makeName(final DataType dataType) { return new Name(dataType.getName()); } @Inject ItemDefinitionUpdateHandler(final DataTypeManager dataTypeManager,
final ItemDefinitionUtils itemDefinitionUtils,
final PropertiesPanelNotifier panelNotifier,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void update(final DataType dataType,
final ItemDefinition itemDefinition); }### Answer:
@Test public void testMakeName() { final DataType dataType = mock(DataType.class); final String expectedName = "name"; when(dataType.getName()).thenReturn(expectedName); final Name name = handler.makeName(dataType); assertEquals(expectedName, name.getValue()); } |
### Question:
ItemDefinitionUpdateHandler { QName makeQName(final DataType dataType) { return normaliseTypeRef(makeQName(dataType.getType())); } @Inject ItemDefinitionUpdateHandler(final DataTypeManager dataTypeManager,
final ItemDefinitionUtils itemDefinitionUtils,
final PropertiesPanelNotifier panelNotifier,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void update(final DataType dataType,
final ItemDefinition itemDefinition); }### Answer:
@Test public void testMakeQNameWhenDataTypeIsDefault() { final DataType dataType = mock(DataType.class); final String expectedName = "string"; when(dataType.getType()).thenReturn(expectedName); final QName name = handler.makeQName(dataType); final String actualName = name.getLocalPart(); assertEquals(expectedName, actualName); assertEquals(QName.NULL_NS_URI, name.getNamespaceURI()); }
@Test public void testMakeQNameWhenDataTypeIsNotDefault() { final DataType dataType = mock(DataType.class); final String expectedName = "tAddress"; when(dataType.getType()).thenReturn(expectedName); final QName name = handler.makeQName(dataType); final String actual = name.toString(); final String expected = "tAddress"; assertEquals(expected, actual); assertEquals(QName.NULL_NS_URI, name.getNamespaceURI()); }
@Test public void testMakeQNameWithItemDefinition() { final ItemDefinition itemDefinition = mock(ItemDefinition.class); final Name itemDefinitionName = mock(Name.class); final String expectedName = "tAddress"; when(itemDefinitionName.getValue()).thenReturn(expectedName); when(itemDefinition.getName()).thenReturn(itemDefinitionName); final QName name = handler.makeQName(itemDefinition); final String actual = name.toString(); final String expected = "tAddress"; assertEquals(expected, actual); assertEquals(QName.NULL_NS_URI, name.getNamespaceURI()); } |
### Question:
ItemDefinitionUpdateHandler { UnaryTests makeAllowedValues(final DataType dataType, final ItemDefinition itemDefinition) { final String constraint = dataType.getConstraint(); if (isEmpty(constraint)) { return null; } if (!Objects.equals(constraint, getText(itemDefinition))) { return new UnaryTests(new Id(), new Description(), new Text(constraint), null, dataType.getConstraintType()); } return itemDefinition.getAllowedValues(); } @Inject ItemDefinitionUpdateHandler(final DataTypeManager dataTypeManager,
final ItemDefinitionUtils itemDefinitionUtils,
final PropertiesPanelNotifier panelNotifier,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void update(final DataType dataType,
final ItemDefinition itemDefinition); }### Answer:
@Test public void testMakeAllowedValuesWhenDataTypeConstraintIsBlank() { final DataType dataType = mock(DataType.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); when(dataType.getConstraint()).thenReturn(""); final UnaryTests actualAllowedValues = handler.makeAllowedValues(dataType, itemDefinition); assertNull(actualAllowedValues); }
@Test public void testMakeAllowedValuesWhenDataTypeConstraintIsNull() { final DataType dataType = mock(DataType.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); when(dataType.getConstraint()).thenReturn(null); when(dataType.getConstraintType()).thenReturn(null); final UnaryTests actualAllowedValues = handler.makeAllowedValues(dataType, itemDefinition); assertNull(actualAllowedValues); } |
### Question:
ItemDefinitionDestroyHandler { public void destroy(final DataType dataType, final boolean notifyPropertiesPanel) { final ItemDefinition itemDefinition = findItemDefinition(dataType); final String destroyedItemDefinition = itemDefinition.getName().getValue(); final Optional<ItemDefinition> itemDefinitionParent = findItemDefinitionParent(dataType); itemDefinitionParent.ifPresent(parent -> { parent.getItemComponent().remove(itemDefinition); }); itemDefinitions().remove(itemDefinition); itemDefinitionStore.unIndex(dataType.getUUID()); if (notifyPropertiesPanel) { notifyPropertiesPanel(destroyedItemDefinition); } } @Inject ItemDefinitionDestroyHandler(final ItemDefinitionStore itemDefinitionStore,
final DMNGraphUtils dmnGraphUtils,
final PropertiesPanelNotifier panelNotifier); void destroy(final DataType dataType, final boolean notifyPropertiesPanel); }### Answer:
@Test public void testDestroy() { final String uuid = "uuid"; final String oldItemDefinitionName = "oldItemDefinitionName"; final DataType dataType = mock(DataType.class); final Name name = mock(Name.class); final ItemDefinition itemDefinition = makeItemDefinition(); final ItemDefinition itemDefinitionParent = makeItemDefinition(itemDefinition); final List<ItemDefinition> itemDefinitions = new ArrayList<ItemDefinition>() {{ add(itemDefinition); }}; when(name.getValue()).thenReturn(oldItemDefinitionName); when(itemDefinitionStore.get(uuid)).thenReturn(itemDefinition); when(dataType.getUUID()).thenReturn(uuid); doReturn(Optional.of(itemDefinitionParent)).when(handler).findItemDefinitionParent(dataType); doReturn(name).when(itemDefinition).getName(); doReturn(itemDefinitions).when(handler).itemDefinitions(); doNothing().when(handler).notifyPropertiesPanel(anyString()); handler.destroy(dataType, true); assertEquals(emptyList(), itemDefinitionParent.getItemComponent()); assertEquals(emptyList(), itemDefinitions); verify(handler).notifyPropertiesPanel(oldItemDefinitionName); } |
### Question:
ItemDefinitionDestroyHandler { void notifyPropertiesPanel(final String destroyedItemDefinition) { panelNotifier .withOldLocalPart(destroyedItemDefinition) .withNewQName(new QName()) .notifyPanel(); } @Inject ItemDefinitionDestroyHandler(final ItemDefinitionStore itemDefinitionStore,
final DMNGraphUtils dmnGraphUtils,
final PropertiesPanelNotifier panelNotifier); void destroy(final DataType dataType, final boolean notifyPropertiesPanel); }### Answer:
@Test public void testNotifyPropertiesPanel() { final String destroyedItemDefinition = "destroyedItemDefinition"; when(panelNotifier.withOldLocalPart(destroyedItemDefinition)).thenReturn(panelNotifier); when(panelNotifier.withNewQName(eq(new QName()))).thenReturn(panelNotifier); handler.notifyPropertiesPanel(destroyedItemDefinition); verify(panelNotifier).notifyPanel(); } |
### Question:
ItemDefinitionDestroyHandler { Optional<ItemDefinition> findItemDefinitionParent(final DataType dataType) { final Optional<ItemDefinition> itemDefinitionParent = Optional.ofNullable(itemDefinitionStore.get(dataType.getParentUUID())); if (itemDefinitionParent.isPresent()) { final ItemDefinition parent = itemDefinitionParent.get(); if (parent.getTypeRef() == null) { return Optional.of(parent); } else { for (final ItemDefinition itemDefinition : itemDefinitions()) { if (Objects.equals(itemDefinition.getName().getValue(), parent.getTypeRef().getLocalPart())) { return Optional.of(itemDefinition); } } } } return Optional.empty(); } @Inject ItemDefinitionDestroyHandler(final ItemDefinitionStore itemDefinitionStore,
final DMNGraphUtils dmnGraphUtils,
final PropertiesPanelNotifier panelNotifier); void destroy(final DataType dataType, final boolean notifyPropertiesPanel); }### Answer:
@Test public void testFindItemDefinitionParentWhenParentDoesNotExist() { final DataType dataType = mock(DataType.class); final String parentUUID = "parentUUID"; when(dataType.getParentUUID()).thenReturn(parentUUID); when(itemDefinitionStore.get(parentUUID)).thenReturn(null); final Optional<ItemDefinition> expectedParent = Optional.empty(); final Optional<ItemDefinition> actualParent = handler.findItemDefinitionParent(dataType); assertEquals(expectedParent, actualParent); }
@Test public void testFindItemDefinitionParentWhenParentDoesNotHaveTypeRef() { final DataType dataType = mock(DataType.class); final ItemDefinition parent = makeItemDefinition(); final String parentUUID = "parentUUID"; when(parent.getTypeRef()).thenReturn(null); when(dataType.getParentUUID()).thenReturn(parentUUID); when(itemDefinitionStore.get(parentUUID)).thenReturn(parent); final Optional<ItemDefinition> expectedParent = Optional.of(parent); final Optional<ItemDefinition> actualParent = handler.findItemDefinitionParent(dataType); assertEquals(expectedParent, actualParent); } |
### Question:
ItemDefinitionDestroyHandler { List<ItemDefinition> itemDefinitions() { final Optional<Definitions> definitions = Optional.ofNullable(dmnGraphUtils.getModelDefinitions()); if (definitions.isPresent()) { return definitions.get().getItemDefinition(); } return new ArrayList<>(); } @Inject ItemDefinitionDestroyHandler(final ItemDefinitionStore itemDefinitionStore,
final DMNGraphUtils dmnGraphUtils,
final PropertiesPanelNotifier panelNotifier); void destroy(final DataType dataType, final boolean notifyPropertiesPanel); }### Answer:
@Test public void testItemDefinitions() { final Definitions definitions = mock(Definitions.class); final ItemDefinition itemDefinition = makeItemDefinition(); final List<ItemDefinition> expectedItemDefinitions = singletonList(itemDefinition); when(dmnGraphUtils.getModelDefinitions()).thenReturn(definitions); when(definitions.getItemDefinition()).thenReturn(expectedItemDefinitions); final List<ItemDefinition> actualItemDefinitions = handler.itemDefinitions(); assertEquals(expectedItemDefinitions, actualItemDefinitions); }
@Test public void testItemDefinitionsWhenDefinitionsIsNull() { final List<ItemDefinition> expectedItemDefinitions = emptyList(); when(dmnGraphUtils.getModelDefinitions()).thenReturn(null); final List<ItemDefinition> actualItemDefinitions = handler.itemDefinitions(); assertEquals(expectedItemDefinitions, actualItemDefinitions); } |
### Question:
DataTypeCreateHandler extends DataTypeHandler { public List<DataType> append(final DataType dataType, final ItemDefinition itemDefinition) { final DataType named; if (Strings.isNullOrEmpty(dataType.getName())) { named = withNoName(dataType); } else { named = dataType; } final DataType updateDataType = updateDataTypeProperties(named, TOP_LEVEL_PARENT_UUID, itemDefinition); return recordEngine.update(updateDataType); } @Inject DataTypeCreateHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); List<DataType> append(final DataType dataType,
final ItemDefinition itemDefinition); List<DataType> insertSibling(final DataType dataType,
final DataType reference,
final CreationType creationType,
final ItemDefinition itemDefinition); List<DataType> insertNested(final DataType dataType,
final DataType reference,
final ItemDefinition itemDefinition); }### Answer:
@Test public void testAppend() { final DataType dataType = mock(DataType.class); final DataType dataTypeWithoutName = mock(DataType.class); final DataType updatedDataType = mock(DataType.class); final DataTypeManager withDataType = mock(DataTypeManager.class); final DataTypeManager withNoName = mock(DataTypeManager.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); final List<DataType> expectedAffectedDataTypes = asList(mock(DataType.class), mock(DataType.class)); when(dataTypeManager.withDataType(dataType)).thenReturn(withDataType); when(withDataType.withNoName()).thenReturn(withNoName); when(withNoName.get()).thenReturn(dataTypeWithoutName); when(recordEngine.update(updatedDataType)).thenReturn(expectedAffectedDataTypes); doReturn(updatedDataType).when(handler).updateDataTypeProperties(dataTypeWithoutName, TOP_LEVEL_PARENT_UUID, itemDefinition); final List<DataType> actualAffectedDataTypes = handler.append(dataType, itemDefinition); assertEquals(expectedAffectedDataTypes, actualAffectedDataTypes); } |
### Question:
DataTypeCreateHandler extends DataTypeHandler { public List<DataType> insertSibling(final DataType dataType, final DataType reference, final CreationType creationType, final ItemDefinition itemDefinition) { final Optional<DataType> parentOptional = lookupAbsoluteParent(reference); if (parentOptional.isPresent()) { final DataType parent = parentOptional.get(); final List<DataType> siblings = parent.getSubDataTypes(); final DataType updatedDataType = updateDataTypeProperties(dataType, parent.getUUID(), itemDefinition); final DataType parentReference = findParentReference(reference, siblings); siblings.add(siblings.indexOf(parentReference) + creationType.getIndexIncrement(), updatedDataType); recordEngine.doUpdate(dataType, itemDefinition); return recordEngine.update(parent); } else { final DataType updatedDataType = updateDataTypeProperties(dataType, reference.getParentUUID(), itemDefinition); recordEngine.doUpdate(updatedDataType, itemDefinition); return new ArrayList<>(); } } @Inject DataTypeCreateHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); List<DataType> append(final DataType dataType,
final ItemDefinition itemDefinition); List<DataType> insertSibling(final DataType dataType,
final DataType reference,
final CreationType creationType,
final ItemDefinition itemDefinition); List<DataType> insertNested(final DataType dataType,
final DataType reference,
final ItemDefinition itemDefinition); }### Answer:
@Test public void testInsertNotNested() { final DataType dataType = mock(DataType.class); final DataType reference = mock(DataType.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); final List<DataType> expectedAffectedDataTypes = asList(mock(DataType.class), mock(DataType.class)); final CreationType creationType = ABOVE; doReturn(expectedAffectedDataTypes).when(handler).insertSibling(dataType, reference, creationType, itemDefinition); final List<DataType> actualAffectedDataTypes = handler.insertSibling(dataType, reference, creationType, itemDefinition); assertEquals(expectedAffectedDataTypes, actualAffectedDataTypes); } |
### Question:
DataTypeCreateHandler extends DataTypeHandler { Optional<DataType> lookupAbsoluteParent(final DataType reference) { final Optional<DataType> optionalParent = Optional.ofNullable(parent(reference)); if (optionalParent.isPresent()) { return fetchTopLevelDataType(optionalParent.get()); } return Optional.empty(); } @Inject DataTypeCreateHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); List<DataType> append(final DataType dataType,
final ItemDefinition itemDefinition); List<DataType> insertSibling(final DataType dataType,
final DataType reference,
final CreationType creationType,
final ItemDefinition itemDefinition); List<DataType> insertNested(final DataType dataType,
final DataType reference,
final ItemDefinition itemDefinition); }### Answer:
@Test public void testLookupAbsoluteParentWhenReferenceDoesNotHaveParent() { final DataType reference = mock(DataType.class); final String parentUUID = "parentUUID"; when(reference.getParentUUID()).thenReturn(parentUUID); when(dataTypeStore.get(parentUUID)).thenReturn(null); final Optional<DataType> absoluteParent = handler.lookupAbsoluteParent(reference); assertFalse(absoluteParent.isPresent()); }
@Test public void testLookupAbsoluteParentWhenReferenceTypeIsStructure() { final DataType reference = mock(DataType.class); final DataType expectedParent = mock(DataType.class); final String parentUUID = "parentUUID"; final String structure = "Structure"; when(reference.getParentUUID()).thenReturn(parentUUID); when(expectedParent.getType()).thenReturn(structure); when(dataTypeStore.get(parentUUID)).thenReturn(expectedParent); when(dataTypeManager.structure()).thenReturn(structure); final Optional<DataType> actualParent = handler.lookupAbsoluteParent(reference); assertEquals(Optional.of(expectedParent), actualParent); }
@Test public void testLookupAbsoluteParentWhenReferenceTypeIsNotStructure() { final DataType reference = mock(DataType.class); final DataType expectedParent = mock(DataType.class); final DataType tCityTopLevel = mock(DataType.class); final String parentUUID = "parentUUID"; final String structure = "Structure"; final String type = "tCity"; when(reference.getParentUUID()).thenReturn(parentUUID); when(expectedParent.getType()).thenReturn(type); when(tCityTopLevel.getName()).thenReturn(type); when(dataTypeStore.get(parentUUID)).thenReturn(expectedParent); when(dataTypeManager.structure()).thenReturn(structure); when(dataTypeStore.getTopLevelDataTypes()).thenReturn(singletonList(tCityTopLevel)); final Optional<DataType> actualParent = handler.lookupAbsoluteParent(reference); assertEquals(Optional.of(tCityTopLevel), actualParent); } |
### Question:
DataTypeCreateHandler extends DataTypeHandler { DataType updateDataTypeProperties(final DataType dataType, final String newParentUUID, final ItemDefinition newItemDefinition) { return dataTypeManager .withDataType(dataType) .withParentUUID(newParentUUID) .withItemDefinition(newItemDefinition) .withIndexedItemDefinition() .withItemDefinitionSubDataTypes() .withUniqueName() .get(); } @Inject DataTypeCreateHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); List<DataType> append(final DataType dataType,
final ItemDefinition itemDefinition); List<DataType> insertSibling(final DataType dataType,
final DataType reference,
final CreationType creationType,
final ItemDefinition itemDefinition); List<DataType> insertNested(final DataType dataType,
final DataType reference,
final ItemDefinition itemDefinition); }### Answer:
@Test public void testUpdateDataType() { final String parentUUID = "parentUUID"; final DataType dataType = mock(DataType.class); final DataType expectedUpdateDataType = mock(DataType.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); final DataTypeManager dataTypeManagerWithDataType = mock(DataTypeManager.class); final DataTypeManager dataTypeManagerWithParentUUID = mock(DataTypeManager.class); final DataTypeManager dataTypeManagerWithItemDefinition = mock(DataTypeManager.class); final DataTypeManager dataTypeManagerWithIndexedItemDefinition = mock(DataTypeManager.class); final DataTypeManager dataTypeManagerWithItemDefinitionSubDataTypes = mock(DataTypeManager.class); final DataTypeManager dataTypeManagerWithUniqueName = mock(DataTypeManager.class); when(dataTypeManager.withDataType(dataType)).thenReturn(dataTypeManagerWithDataType); when(dataTypeManagerWithDataType.withParentUUID(parentUUID)).thenReturn(dataTypeManagerWithParentUUID); when(dataTypeManagerWithParentUUID.withItemDefinition(itemDefinition)).thenReturn(dataTypeManagerWithItemDefinition); when(dataTypeManagerWithItemDefinition.withIndexedItemDefinition()).thenReturn(dataTypeManagerWithIndexedItemDefinition); when(dataTypeManagerWithIndexedItemDefinition.withItemDefinitionSubDataTypes()).thenReturn(dataTypeManagerWithItemDefinitionSubDataTypes); when(dataTypeManagerWithItemDefinitionSubDataTypes.withUniqueName()).thenReturn(dataTypeManagerWithUniqueName); when(dataTypeManagerWithUniqueName.get()).thenReturn(expectedUpdateDataType); final DataType actualUpdatedDataType = handler.updateDataTypeProperties(dataType, parentUUID, itemDefinition); assertEquals(expectedUpdateDataType, actualUpdatedDataType); } |
### Question:
DataTypeHandler { public void init(final ItemDefinitionRecordEngine recordEngine) { this.recordEngine = recordEngine; } DataTypeHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void init(final ItemDefinitionRecordEngine recordEngine); }### Answer:
@Test public void testInit() { final ItemDefinitionRecordEngine expectedRecordEngine = mock(ItemDefinitionRecordEngine.class); handler.init(expectedRecordEngine); final ItemDefinitionRecordEngine actualRecordEngine = handler.getRecordEngine(); assertEquals(expectedRecordEngine, actualRecordEngine); } |
### Question:
ImportedItemDefinitionConverter { public static ItemDefinition wbFromDMN(final org.kie.dmn.model.api.ItemDefinition dmnItemDefinition, final String prefix) { final org.kie.dmn.model.api.ItemDefinition dmnItemDefinitionWithNamespace = withNamespace(dmnItemDefinition, prefix); final ItemDefinition wbItemDefinition = ItemDefinitionPropertyConverter.wbFromDMN(dmnItemDefinitionWithNamespace); allowOnlyVisualChange(wbItemDefinition); return wbItemDefinition; } static ItemDefinition wbFromDMN(final org.kie.dmn.model.api.ItemDefinition dmnItemDefinition,
final String prefix); static org.kie.dmn.model.api.ItemDefinition withNamespace(final org.kie.dmn.model.api.ItemDefinition itemDefinition,
final String prefix); }### Answer:
@Test public void testWbFromDMN() { final org.kie.dmn.model.api.ItemDefinition itemDefinition = new TItemDefinition(); final org.kie.dmn.model.api.ItemDefinition itemComponent1 = new TItemDefinition(); final org.kie.dmn.model.api.ItemDefinition itemComponent2 = new TItemDefinition(); final org.kie.dmn.model.api.ItemDefinition itemComponent3 = new TItemDefinition(); itemDefinition.setName("tPerson"); itemDefinition.setTypeRef(null); itemDefinition.getItemComponent().addAll(asList(itemComponent1, itemComponent2, itemComponent3)); itemComponent1.setName("id"); itemComponent1.setTypeRef(new QName("tUUID")); itemComponent2.setName("name"); itemComponent2.setTypeRef(new QName("string")); itemComponent3.setName("age"); itemComponent3.setTypeRef(new QName("number")); final ItemDefinition actualItemDefinition = ImportedItemDefinitionConverter.wbFromDMN(itemDefinition, "model"); assertEquals("model.tPerson", actualItemDefinition.getName().getValue()); assertNull(actualItemDefinition.getTypeRef()); assertTrue(actualItemDefinition.isAllowOnlyVisualChange()); assertEquals(3, actualItemDefinition.getItemComponent().size()); final ItemDefinition actualItemDefinition1 = actualItemDefinition.getItemComponent().get(0); assertEquals("model.id", actualItemDefinition1.getName().getValue()); assertEquals("model.tUUID", actualItemDefinition1.getTypeRef().getLocalPart()); assertTrue(actualItemDefinition1.isAllowOnlyVisualChange()); final ItemDefinition actualItemDefinition2 = actualItemDefinition.getItemComponent().get(1); assertEquals("model.name", actualItemDefinition2.getName().getValue()); assertEquals("string", actualItemDefinition2.getTypeRef().getLocalPart()); assertTrue(actualItemDefinition2.isAllowOnlyVisualChange()); final ItemDefinition actualItemDefinition3 = actualItemDefinition.getItemComponent().get(2); assertEquals("model.age", actualItemDefinition3.getName().getValue()); assertEquals("number", actualItemDefinition3.getTypeRef().getLocalPart()); assertTrue(actualItemDefinition3.isAllowOnlyVisualChange()); } |
### Question:
DMNPathsHelperImpl implements DMNPathsHelper { @Override public List<Path> getPMMLModelsPaths(final WorkspaceProject workspaceProject) { if (workspaceProject != null) { return getPathsByWorkspaceProject(pmmlQueryTerms(workspaceProject.getRootPath().toURI())); } else { return getStandalonePaths(pmmlDocumentFilter()); } } DMNPathsHelperImpl(); @Inject DMNPathsHelperImpl(final RefactoringQueryService refactoringQueryService,
final DMNImportTypesHelper importTypesHelper,
final @Named("ioStrategy") IOService ioService); @Override List<Path> getModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getDMNModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getPMMLModelsPaths(final WorkspaceProject workspaceProject); @Override String getRelativeURI(final Path dmnModelPath,
final Path includedModelPath); }### Answer:
@Test public void testGetPMMLDocumentsPathsWhenWorkspaceProjectIsNull() { doTestGetPathsWhenWorkspaceProjectIsNull(workspaceProject1 -> pathsHelper.getPMMLModelsPaths(null)); }
@Test public void testGetPMMLDocumentsPathsWhenWorkspaceProjectIsNotNull() { doTestGetPathsWhenWorkspaceProjectIsNotNull(workspaceProject -> pathsHelper.getPMMLModelsPaths(workspaceProject)); } |
### Question:
DataTypeHandler { Optional<DataType> getClosestTopLevelDataType(final DataType dataType) { final Optional<DataType> closestTopLevelDataType = getClosestTopLevel(parent(dataType)); if (closestTopLevelDataType.isPresent()) { final DataType topLevel = closestTopLevelDataType.get(); final String type = topLevel.isTopLevel() ? topLevel.getName() : topLevel.getType(); return findTopLevelDataTypeByName(type); } return Optional.empty(); } DataTypeHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void init(final ItemDefinitionRecordEngine recordEngine); }### Answer:
@Test public void testGetClosestTopLevelDataType() { final DataType dataType0 = makeDataType("name", "Text", false); final DataType dataType1 = makeDataType("name", "Text", false); final DataType dataType2 = makeDataType("name", "Text", false); final DataType dataType3 = makeDataType("city", "tCity", false); final DataType dataType5 = makeDataType("street", "Structure", false, dataType1); final DataType dataType4 = makeDataType("tCity", "Structure", true, dataType0, dataType5); final DataType dataType6 = makeDataType("tPerson", "Structure", true, dataType2, dataType3); doReturn(dataType4).when(handler).parent(dataType0); doReturn(dataType4).when(handler).parent(dataType5); doReturn(dataType5).when(handler).parent(dataType1); doReturn(dataType6).when(handler).parent(dataType2); doReturn(dataType6).when(handler).parent(dataType3); when(dataTypeStore.getTopLevelDataTypes()).thenReturn(asList(dataType4, dataType6)); final DataType closestTopLevelDataTypeForDataType1 = handler.getClosestTopLevelDataType(dataType1).orElseThrow(UnsupportedOperationException::new); final DataType closestTopLevelDataTypeForDataType3 = handler.getClosestTopLevelDataType(dataType3).orElseThrow(UnsupportedOperationException::new); assertEquals(dataType4, closestTopLevelDataTypeForDataType1); assertEquals(dataType6, closestTopLevelDataTypeForDataType3); } |
### Question:
DataTypeHandler { List<DataType> getSubDataTypesByType(final String type) { return new DataTypeQuery().where(dataType -> Objects.equals(dataType.getType(), type)).collect(); } DataTypeHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void init(final ItemDefinitionRecordEngine recordEngine); }### Answer:
@Test public void testGetSubDataTypesByType() { final String type = "tCity"; final DataType dataType0 = makeDataType("tPerson", "Structure"); final DataType dataType1 = makeDataType("tCity", "Structure"); final DataType dataType2 = makeDataType("city1", "tCity"); final DataType dataType3 = makeDataType("city2", "tCity"); final DataType dataType4 = makeDataType("tCompany", "Structure"); when(dataTypeStore.getTopLevelDataTypes()).thenReturn(asList(dataType0, dataType1, dataType2, dataType3, dataType4)); final List<DataType> expectedDataTypes = asList(dataType2, dataType3); final List<DataType> actualDataTypes = handler.getSubDataTypesByType(type); assertEquals(expectedDataTypes, actualDataTypes); } |
### Question:
DataTypeHandler { List<DataType> forEachSubDataTypesByType(final String type, final Consumer<DataType> consumer) { return new DataTypeQuery().where(dataType -> Objects.equals(dataType.getType(), type)).apply(consumer).collect(); } DataTypeHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void init(final ItemDefinitionRecordEngine recordEngine); }### Answer:
@Test public void testForEachSubDataTypesByType() { final String type = "tCity"; final DataType dataType0 = makeDataType("tPerson", "Structure"); final DataType dataType1 = makeDataType("tCity", "Structure"); final DataType dataType2 = makeDataType("city1", "tCity"); final DataType dataType3 = makeDataType("city2", "tCity"); final DataType dataType4 = makeDataType("tCompany", "Structure"); when(dataTypeStore.getTopLevelDataTypes()).thenReturn(asList(dataType0, dataType1, dataType2, dataType3, dataType4)); final List<DataType> actualDataTypes = new ArrayList<>(); final List<DataType> expectedDataTypes = asList(dataType2, dataType3); final List<DataType> forEachSubDataTypesByType = handler.forEachSubDataTypesByType(type, actualDataTypes::add); assertEquals(expectedDataTypes, actualDataTypes); assertEquals(expectedDataTypes, forEachSubDataTypesByType); } |
### Question:
DataTypeHandler { List<DataType> forEachSubDataTypesByTypeOrName(final String typeOrName, final Consumer<DataType> consumer) { return new DataTypeQuery() .where(dataType -> Objects.equals(dataType.getType(), typeOrName) || Objects.equals(dataType.getName(), typeOrName)) .apply(consumer) .collect(); } DataTypeHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void init(final ItemDefinitionRecordEngine recordEngine); }### Answer:
@Test public void testForEachSubDataTypesByTypeOrName() { final String type = "tCompany"; final DataType dataType0 = makeDataType("RedHat", "tCompany"); final DataType dataType1 = makeDataType("tPerson", "Structure"); final DataType dataType2 = makeDataType("tCity", "Structure"); final DataType dataType3 = makeDataType("city1", "tCity"); final DataType dataType4 = makeDataType("city2", "tCity"); final DataType dataType5 = makeDataType("tCompany", "Structure"); when(dataTypeStore.getTopLevelDataTypes()).thenReturn(asList(dataType0, dataType1, dataType2, dataType3, dataType4, dataType5)); final List<DataType> actualDataTypes = new ArrayList<>(); final List<DataType> expectedDataTypes = asList(dataType0, dataType5); final List<DataType> forEachSubDataTypesByType = handler.forEachSubDataTypesByTypeOrName(type, actualDataTypes::add); assertEquals(expectedDataTypes, actualDataTypes); assertEquals(expectedDataTypes, forEachSubDataTypesByType); } |
### Question:
DataTypeHandler { void refreshSubDataTypes(final DataType dataType) { final String type = dataTypeManager.withDataType(dataType).getTypeName(); refreshSubDataTypes(dataType, type); } DataTypeHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void init(final ItemDefinitionRecordEngine recordEngine); }### Answer:
@Test public void testRefreshSubDataTypes() { final DataTypeManager dataTypeManagerWithDataType = mock(DataTypeManager.class); final DataType dataType = makeDataType(); final String type = "type"; doNothing().when(handler).refreshSubDataTypes(any(), anyString()); when(dataTypeManager.withDataType(dataType)).thenReturn(dataTypeManagerWithDataType); when(dataTypeManagerWithDataType.getTypeName()).thenReturn(type); handler.refreshSubDataTypes(dataType); verify(handler).refreshSubDataTypes(dataType, type); }
@Test public void testRefreshSubDataTypesWithNewType() { final DataType dataType = makeDataType(); final String newType = "newType"; when(dataTypeManager.from(any(DataType.class))).thenReturn(dataTypeManager); when(dataTypeManager.withRefreshedSubDataTypes(anyString())).thenReturn(dataTypeManager); handler.refreshSubDataTypes(dataType, newType); final InOrder inOrder = Mockito.inOrder(dataTypeManager); inOrder.verify(dataTypeManager).from(dataType); inOrder.verify(dataTypeManager).withRefreshedSubDataTypes(newType); } |
### Question:
DataTypeHandler { DataType parent(final DataType dataType) { return dataTypeStore.get(dataType.getParentUUID()); } DataTypeHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void init(final ItemDefinitionRecordEngine recordEngine); }### Answer:
@Test public void testParent() { final DataType dataType = makeDataType(); final DataType expectedParent = makeDataType(); final String parentUUID = "parentUUID"; when(dataType.getParentUUID()).thenReturn(parentUUID); when(dataTypeStore.get(parentUUID)).thenReturn(expectedParent); final DataType actualParent = handler.parent(dataType); assertEquals(expectedParent, actualParent); } |
### Question:
DataTypeHandler { boolean isStructure(final DataType dataType) { return Objects.equals(dataType.getType(), dataTypeManager.structure()); } DataTypeHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void init(final ItemDefinitionRecordEngine recordEngine); }### Answer:
@Test public void testIsStructureWhenItReturnsTrue() { final DataType dataType = mock(DataType.class); final String structure = "Structure"; when(dataTypeManager.structure()).thenReturn(structure); when(dataType.getType()).thenReturn(structure); assertTrue(handler.isStructure(dataType)); }
@Test public void testIsStructureWhenItReturnsFalse() { final DataType dataType = mock(DataType.class); when(dataTypeManager.structure()).thenReturn("Structure"); when(dataType.getType()).thenReturn("tCity"); assertFalse(handler.isStructure(dataType)); } |
### Question:
PropertiesPanelNotifier { public void notifyPanel() { for (final Node node : getNodes()) { final Object definition = getDefinition(node); notifyVariables(node, definition); notifyExpressions(node, definition); } } @Inject PropertiesPanelNotifier(final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final SessionManager sessionManager); PropertiesPanelNotifier withOldLocalPart(final String oldLocalPart); PropertiesPanelNotifier withNewQName(final QName newQName); void notifyPanel(); }### Answer:
@Test public void testNotifyPanel() { final Node node1 = mock(Node.class); final Node node2 = mock(Node.class); final Object definition1 = mock(Object.class); final Object definition2 = mock(Object.class); doReturn(asList(node1, node2)).when(notifier).getNodes(); doReturn(definition1).when(notifier).getDefinition(node1); doReturn(definition2).when(notifier).getDefinition(node2); notifier.notifyPanel(); verify(notifier).notifyVariables(node1, definition1); verify(notifier).notifyExpressions(node2, definition2); } |
### Question:
RuleAnnotationClauseConverter { public static RuleAnnotationClause wbFromDMN(final org.kie.dmn.model.api.RuleAnnotationClause ruleAnnotationClause) { if (ruleAnnotationClause == null) { return null; } final RuleAnnotationClause rule = new RuleAnnotationClause(); rule.setName(new Name(ruleAnnotationClause.getName())); return rule; } static RuleAnnotationClause wbFromDMN(final org.kie.dmn.model.api.RuleAnnotationClause ruleAnnotationClause); static org.kie.dmn.model.api.RuleAnnotationClause dmnFromWB(final RuleAnnotationClause wb); }### Answer:
@Test public void testWbFromDMN() { final String name = "name"; when(ruleAnnotationClause.getName()).thenReturn(name); final RuleAnnotationClause converted = RuleAnnotationClauseConverter.wbFromDMN(ruleAnnotationClause); assertEquals(name, converted.getName().getValue()); }
@Test public void testWbFromDMNWhenIsNull() { final RuleAnnotationClause converted = RuleAnnotationClauseConverter.wbFromDMN(null); assertNull(converted); } |
### Question:
PropertiesPanelNotifier { void onCanvasSelectionEvent(final @Observes CanvasSelectionEvent event) { final Collection<String> identifiers = event.getIdentifiers(); if (identifiers.size() > 0) { setSelectedElementUUID(identifiers.iterator().next()); } } @Inject PropertiesPanelNotifier(final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final SessionManager sessionManager); PropertiesPanelNotifier withOldLocalPart(final String oldLocalPart); PropertiesPanelNotifier withNewQName(final QName newQName); void notifyPanel(); }### Answer:
@Test public void testOnCanvasSelectionEvent() { final CanvasSelectionEvent selectionEvent = mock(CanvasSelectionEvent.class); final String uuid1 = "uuid1"; final String uuid2 = "uuid2"; final List<String> t = asList(uuid1, uuid2); when(selectionEvent.getIdentifiers()).thenReturn(t); notifier.onCanvasSelectionEvent(selectionEvent); verify(notifier).setSelectedElementUUID(uuid1); } |
### Question:
PropertiesPanelNotifier { void onDomainObjectSelectionEvent(final @Observes DomainObjectSelectionEvent event) { setSelectedElementUUID(event.getDomainObject().getDomainObjectUUID()); } @Inject PropertiesPanelNotifier(final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final SessionManager sessionManager); PropertiesPanelNotifier withOldLocalPart(final String oldLocalPart); PropertiesPanelNotifier withNewQName(final QName newQName); void notifyPanel(); }### Answer:
@Test public void testOnDomainObjectSelectionEvent() { final DomainObjectSelectionEvent selectionEvent = mock(DomainObjectSelectionEvent.class); final DomainObject domainObject = mock(DomainObject.class); final String uuid = "uuid"; when(selectionEvent.getDomainObject()).thenReturn(domainObject); when(domainObject.getDomainObjectUUID()).thenReturn(uuid); notifier.onDomainObjectSelectionEvent(selectionEvent); verify(notifier).setSelectedElementUUID(uuid); } |
### Question:
PropertiesPanelNotifier { void notifyExpressions(final Node node, final Object definition) { if (definition instanceof HasExpression) { final HasExpression hasExpression = asHasExpression(definition); final List<HasTypeRef> hasTypeRefs = getNotNullHasTypeRefs(hasExpression.getExpression()); for (final HasTypeRef hasTypeRef : hasTypeRefs) { notifyOutdatedElement(node, hasTypeRef); } } } @Inject PropertiesPanelNotifier(final Event<RefreshFormPropertiesEvent> refreshFormPropertiesEvent,
final SessionManager sessionManager); PropertiesPanelNotifier withOldLocalPart(final String oldLocalPart); PropertiesPanelNotifier withNewQName(final QName newQName); void notifyPanel(); }### Answer:
@Test public void testNotifyExpressions() { final Node node = mock(Node.class); final HasExpression hasExpression = mock(HasExpression.class); final Expression expression = mock(Expression.class); final HasTypeRef hasTypeRef1 = mock(HasTypeRef.class); final HasTypeRef hasTypeRef2 = mock(HasTypeRef.class); when(expression.getHasTypeRefs()).thenReturn(asList(hasTypeRef1, hasTypeRef2)); when(hasExpression.getExpression()).thenReturn(expression); doNothing().when(notifier).notifyOutdatedElement(any(), any()); notifier.notifyExpressions(node, hasExpression); verify(notifier).notifyOutdatedElement(node, hasTypeRef1); verify(notifier).notifyOutdatedElement(node, hasTypeRef2); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.