method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
PropertiesPanelNotifier { void notifyVariables(final Node node, final Object definition) { if (definition instanceof HasVariable) { notifyOutdatedElement(node, asHasVariable(definition).getVariable()); } } @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 testNotifyVariables() { final Node node = mock(Node.class); final HasVariable hasVariable = mock(HasVariable.class); final IsInformationItem informationItem = mock(IsInformationItem.class); when(hasVariable.getVariable()).thenReturn(informationItem); doNothing().when(notifier).notifyOutdatedElement(any(), any()); notifier.notifyVariables(node, hasVariable); verify(notifier).notifyOutdatedElement(node, informationItem); } |
### Question:
PropertiesPanelNotifier { Object getDefinition(final Node node) { final ViewImpl content = (ViewImpl) node.getContent(); return content.getDefinition(); } @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 testGetDefinition() { final Node node = mock(Node.class); final ViewImpl content = mock(ViewImpl.class); final Object expected = mock(Object.class); when(content.getDefinition()).thenReturn(expected); when(node.getContent()).thenReturn(content); final Object actual = notifier.getDefinition(node); assertEquals(expected, actual); } |
### Question:
PropertiesPanelNotifier { List<Node> getNodes() { final List<Node> nodes = new ArrayList<>(); getGraph().ifPresent(graph -> { graph.nodes().forEach(nodes::add); }); return nodes; } @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 testGetNodes() { final Graph graph = mock(Graph.class); final Node node1 = mock(Node.class); final Node node2 = mock(Node.class); final Iterable<Node> expectedNodes = asList(node1, node2); when(graph.nodes()).thenReturn(expectedNodes); doReturn(Optional.of(graph)).when(notifier).getGraph(); final List<Node> actualNodes = notifier.getNodes(); assertEquals(expectedNodes, actualNodes); } |
### Question:
PropertiesPanelNotifier { Optional<Graph<?, Node>> getGraph() { final Optional<CanvasHandler> canvasHandler = getCurrentSession().map(ClientSession::getCanvasHandler); final Optional<Diagram> diagram = canvasHandler.map(CanvasHandler::getDiagram); return diagram.map(Diagram::getGraph); } @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 testGetGraph() { final ClientSession clientSession = mock(ClientSession.class); final CanvasHandler canvasHandler = mock(CanvasHandler.class); final Diagram diagram = mock(Diagram.class); final Optional<Graph> expected = Optional.of(mock(Graph.class)); when(diagram.getGraph()).thenReturn(expected.get()); when(canvasHandler.getDiagram()).thenReturn(diagram); when(clientSession.getCanvasHandler()).thenReturn(canvasHandler); when(sessionManager.getCurrentSession()).thenReturn(clientSession); final Optional<Graph<?, Node>> actual = notifier.getGraph(); assertEquals(expected, actual); } |
### Question:
DataTypeUpdateHandler extends DataTypeHandler { public void update(final DataType dataType) { final String type = getTypeName(dataType); if (!isBuiltInType(type)) { dataTypeManager .from(dataType) .withRefreshedSubDataTypes(type); } } @Inject DataTypeUpdateHandler(final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void update(final DataType dataType); List<DataType> refreshDependentDataTypes(final DataType dataType,
final String oldItemDefinitionName); }### Answer:
@Test public void testUpdateWhenDataTypeIsDefault() { final DataType dataType = mock(DataType.class); when(dataType.getType()).thenReturn(BuiltInType.STRING.getName()); handler.update(dataType); verify(dataTypeManager, never()).from(any(DataType.class)); verify(dataTypeManager, never()).withRefreshedSubDataTypes(anyString()); }
@Test public void testUpdateWhenDataTypeIsNotDefault() { final DataType dataType = mock(DataType.class); final String name = "city"; final String type = "tCity"; when(dataType.getName()).thenReturn(name); when(dataType.getType()).thenReturn(type); when(dataTypeManager.from(any(DataType.class))).thenReturn(dataTypeManager); when(dataTypeManager.withRefreshedSubDataTypes(anyString())).thenReturn(dataTypeManager); handler.update(dataType); final InOrder inOrder = Mockito.inOrder(dataTypeManager); inOrder.verify(dataTypeManager).from(dataType); inOrder.verify(dataTypeManager).withRefreshedSubDataTypes(type); } |
### Question:
DataTypeUpdateHandler extends DataTypeHandler { public List<DataType> refreshDependentDataTypes(final DataType dataType, final String oldItemDefinitionName) { final List<DataType> affectedDataTypes = new ArrayList<>(); affectedDataTypes.addAll(handleTopLevelDataTypeUpdate(dataType, oldItemDefinitionName)); affectedDataTypes.addAll(handleNestedDataTypeFieldUpdate(dataType)); return affectedDataTypes; } @Inject DataTypeUpdateHandler(final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void update(final DataType dataType); List<DataType> refreshDependentDataTypes(final DataType dataType,
final String oldItemDefinitionName); }### Answer:
@Test public void testRefreshDependentDataTypes() { final DataType dataType = mock(DataType.class); final String oldItemDefinitionName = "oldItemDefinitionName"; final DataType dataType0 = mock(DataType.class); final DataType dataType1 = mock(DataType.class); final DataType dataType2 = mock(DataType.class); final DataType dataType3 = mock(DataType.class); doReturn(asList(dataType0, dataType1)).when(handler).handleTopLevelDataTypeUpdate(dataType, oldItemDefinitionName); doReturn(asList(dataType2, dataType3)).when(handler).handleNestedDataTypeFieldUpdate(dataType); final List<DataType> expectedDataTypes = asList(dataType0, dataType1, dataType2, dataType3); final List<DataType> actualDataTypes = handler.refreshDependentDataTypes(dataType, oldItemDefinitionName); assertEquals(expectedDataTypes, actualDataTypes); } |
### Question:
DataTypeUpdateHandler extends DataTypeHandler { List<DataType> handleTopLevelDataTypeUpdate(final DataType dataType, final String oldItemDefinitionName) { return updateAllChildrenWithTheNewTypeName(dataType, oldItemDefinitionName); } @Inject DataTypeUpdateHandler(final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void update(final DataType dataType); List<DataType> refreshDependentDataTypes(final DataType dataType,
final String oldItemDefinitionName); }### Answer:
@Test public void testHandleTopLevelDataTypeUpdate() { final DataType dataType = mock(DataType.class); final DataType dataType0 = mock(DataType.class); final DataType dataType1 = mock(DataType.class); final List<DataType> expectedDataTypes = asList(dataType0, dataType1); final String oldItemDefinitionName = "oldItemDefinitionName"; doReturn(expectedDataTypes).when(handler).updateAllChildrenWithTheNewTypeName(dataType, oldItemDefinitionName); final List<DataType> actualDataTypes = handler.handleTopLevelDataTypeUpdate(dataType, oldItemDefinitionName); assertEquals(expectedDataTypes, actualDataTypes); } |
### Question:
DataTypeUpdateHandler extends DataTypeHandler { List<DataType> handleNestedDataTypeFieldUpdate(final DataType dataType) { final List<DataType> affectedDataTypes = new ArrayList<>(); getClosestTopLevelDataType(dataType) .ifPresent(topLevelUpdate -> { refreshSubDataTypes(topLevelUpdate, topLevelUpdate.getName()); if (!isStructure(topLevelUpdate)) { forEachSubDataTypesByTypeOrName(topLevelUpdate.getType(), subDataType -> { refreshSubDataTypes(subDataType, topLevelUpdate.getType()); affectedDataTypes.add(subDataType); }); } else { affectedDataTypes.addAll(handleTopLevelDataTypeUpdate(topLevelUpdate, topLevelUpdate.getName())); } affectedDataTypes.add(topLevelUpdate); }); return affectedDataTypes; } @Inject DataTypeUpdateHandler(final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void update(final DataType dataType); List<DataType> refreshDependentDataTypes(final DataType dataType,
final String oldItemDefinitionName); }### Answer:
@Test public void testHandleNestedDataTypeFieldUpdateWhenDataTypeIsNotStructure() { final DataType dataType = mock(DataType.class); final DataType topLevelDataType = mock(DataType.class); final DataType dataType0 = mock(DataType.class); final DataType dataType1 = mock(DataType.class); final DataType dataType2 = mock(DataType.class); final String name = "name"; final String type = "type"; when(dataType0.getType()).thenReturn(name); when(dataType1.getType()).thenReturn(type); when(dataType2.getName()).thenReturn(type); when(topLevelDataType.getName()).thenReturn(name); when(topLevelDataType.getType()).thenReturn(type); when(dataTypeStore.getTopLevelDataTypes()).thenReturn(asList(dataType0, dataType1, dataType2)); doReturn(Optional.of(topLevelDataType)).when(handler).getClosestTopLevelDataType(dataType); doReturn(false).when(handler).isStructure(dataType); doNothing().when(handler).refreshSubDataTypes(any(), anyString()); final List<DataType> expectedDataTypes = asList(dataType1, dataType2, topLevelDataType); final List<DataType> actualDataTypes = handler.handleNestedDataTypeFieldUpdate(dataType); verify(handler).refreshSubDataTypes(topLevelDataType, name); verify(handler).refreshSubDataTypes(dataType1, type); verify(handler).refreshSubDataTypes(dataType2, type); assertEquals(expectedDataTypes, actualDataTypes); } |
### Question:
DataTypeUpdateHandler extends DataTypeHandler { void refreshSubDataType(final DataType dataType, final String newType) { final ItemDefinition itemDefinition = itemDefinitionStore.get(dataType.getUUID()); dataTypeManager.from(dataType).withType(newType); recordEngine.doUpdate(dataType, itemDefinition); refreshSubDataTypes(dataType, dataType.getType()); } @Inject DataTypeUpdateHandler(final ItemDefinitionStore itemDefinitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void update(final DataType dataType); List<DataType> refreshDependentDataTypes(final DataType dataType,
final String oldItemDefinitionName); }### Answer:
@Test public void testRefreshSubDataType() { final DataType dataType = mock(DataType.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); final String newType = "newType"; final String type = "type"; final String uuid = "uuid"; when(dataType.getType()).thenReturn(type); when(dataType.getUUID()).thenReturn(uuid); when(itemDefinitionStore.get(uuid)).thenReturn(itemDefinition); when(dataTypeManager.from(dataType)).thenReturn(dataTypeManager); when(dataTypeManager.withType(newType)).thenReturn(dataTypeManager); handler.refreshSubDataType(dataType, newType); final InOrder inOrder = Mockito.inOrder(dataTypeManager, dataTypeManager, recordEngine, handler); inOrder.verify(dataTypeManager).from(dataType); inOrder.verify(dataTypeManager).withType(newType); inOrder.verify(recordEngine).doUpdate(dataType, itemDefinition); inOrder.verify(handler).refreshSubDataTypes(dataType, type); } |
### Question:
DataTypeDestroyHandler extends DataTypeHandler { public void destroy(final DataType dataType) { final Optional<DataType> dataTypeParent = Optional.ofNullable(parent(dataType)); dataTypeParent.ifPresent(parent -> { parent.getSubDataTypes().remove(dataType); }); unIndex(dataType); } @Inject DataTypeDestroyHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void destroy(final DataType dataType); List<DataType> refreshDependentDataTypes(final DataType dataType); }### Answer:
@Test public void testDestroy() { final String uuid = "uuid"; final String parentUUID = "parentUUID"; final String childUUID1 = "childUUID1"; final String childUUID2 = "childUUID2"; final String grandchildUUID1 = "grandchildUUID1"; final String grandchildUUID2 = "grandchildUUID2"; final DataType[] grandchildren = {makeDataType(grandchildUUID1), makeDataType(grandchildUUID2)}; final DataType[] children = {makeDataType(childUUID1), makeDataType(childUUID2, grandchildren)}; final DataType dataType = makeDataType(uuid, children); final DataType parent = makeDataType(parentUUID, dataType); doReturn(parent).when(handler).parent(dataType); handler.destroy(dataType); verify(dataTypeStore).unIndex(uuid); verify(dataTypeStore).unIndex(childUUID1); verify(dataTypeStore).unIndex(childUUID2); verify(dataTypeStore).unIndex(grandchildUUID1); verify(dataTypeStore).unIndex(grandchildUUID2); assertEquals(emptyList(), parent.getSubDataTypes()); } |
### Question:
DataTypeDestroyHandler extends DataTypeHandler { public List<DataType> refreshDependentDataTypes(final DataType dataType) { final List<DataType> affectedDataTypes = new ArrayList<>(); affectedDataTypes.addAll(handleTopLevelDataTypes(dataType)); affectedDataTypes.addAll(handleNestedDataTypes(dataType)); return affectedDataTypes; } @Inject DataTypeDestroyHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void destroy(final DataType dataType); List<DataType> refreshDependentDataTypes(final DataType dataType); }### Answer:
@Test public void testRefreshDependentDataTypes() { final DataType dataType = mock(DataType.class); final DataType dataType0 = mock(DataType.class); final DataType dataType1 = mock(DataType.class); final DataType dataType2 = mock(DataType.class); final DataType dataType3 = mock(DataType.class); doReturn(asList(dataType0, dataType1)).when(handler).handleTopLevelDataTypes(dataType); doReturn(asList(dataType2, dataType3)).when(handler).handleNestedDataTypes(dataType); final List<DataType> expectedDataTypes = asList(dataType0, dataType1, dataType2, dataType3); final List<DataType> actualDataTypes = handler.refreshDependentDataTypes(dataType); assertEquals(expectedDataTypes, actualDataTypes); } |
### Question:
DataTypeDestroyHandler extends DataTypeHandler { List<DataType> handleTopLevelDataTypes(final DataType dataType) { final List<DataType> affected = new ArrayList<>(); if (!dataType.isTopLevel()) { return affected; } final List<DataType> dataTypesByType = getSubDataTypesByType(dataType.getName()); for (final DataType dt : dataTypesByType) { final Optional<DataType> dataTypeParent = Optional.ofNullable(parent(dt)); recordEngine.doDestroy(dt); affected.add(dataTypeParent.orElse(dt)); } affected.add(dataType); return affected; } @Inject DataTypeDestroyHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void destroy(final DataType dataType); List<DataType> refreshDependentDataTypes(final DataType dataType); }### Answer:
@Test public void testHandleTopLevelDataTypesWhenDataTypeIsNotTopLevel() { final DataType dataType = mock(DataType.class); when(dataType.isTopLevel()).thenReturn(false); final List<DataType> expectedDependentDataTypes = emptyList(); final List<DataType> actualDependentDataTypes = handler.handleTopLevelDataTypes(dataType); verify(recordEngine, never()).doDestroy(any()); assertEquals(expectedDependentDataTypes, actualDependentDataTypes); }
@Test public void testHandleTopLevelDataTypesWhenDataTypeIsTopLevel() { final DataType dataType = mock(DataType.class); final DataType dataType0 = mock(DataType.class); final DataType dataType1 = mock(DataType.class); final DataType dataType2 = mock(DataType.class); final DataType dataTypeParent0 = mock(DataType.class); final DataType dataTypeParent1 = mock(DataType.class); final String topLevelName = "name"; when(dataType.isTopLevel()).thenReturn(true); when(dataType.getName()).thenReturn(topLevelName); when(dataType0.getType()).thenReturn(topLevelName); when(dataType1.getType()).thenReturn(topLevelName); when(dataType2.getType()).thenReturn(topLevelName); when(dataTypeStore.getTopLevelDataTypes()).thenReturn(asList(dataType0, dataType1, dataType2)); doReturn(dataTypeParent0).when(handler).parent(dataType0); doReturn(dataTypeParent1).when(handler).parent(dataType1); final List<DataType> expectedDependentDataTypes = asList(dataTypeParent0, dataTypeParent1, dataType2, dataType); final List<DataType> actualDependentDataTypes = handler.handleTopLevelDataTypes(dataType); verify(recordEngine).doDestroy(dataType0); verify(recordEngine).doDestroy(dataType1); verify(recordEngine).doDestroy(dataType2); assertEquals(expectedDependentDataTypes, actualDependentDataTypes); } |
### Question:
DataTypeDestroyHandler extends DataTypeHandler { List<DataType> handleNestedDataTypes(final DataType dataType) { final List<DataType> affectedDataTypes = new ArrayList<>(); getClosestTopLevelDataType(dataType).ifPresent(topLevel -> { final String type = topLevel.getName(); affectedDataTypes.add(topLevel); refreshSubDataTypes(topLevel, type); if (!isStructure(topLevel)) { forEachSubDataTypesByTypeOrName(topLevel.getType(), subDataType -> { affectedDataTypes.add(refreshSubDataType(subDataType)); }); } forEachSubDataTypesByType(type, subDataType -> { affectedDataTypes.add(refreshSubDataType(subDataType)); }); }); return affectedDataTypes; } @Inject DataTypeDestroyHandler(final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager); void destroy(final DataType dataType); List<DataType> refreshDependentDataTypes(final DataType dataType); }### Answer:
@Test public void testHandleNestedDataTypes() { final DataType dataType = mock(DataType.class); final DataType dataType0 = mock(DataType.class); final DataType dataType1 = mock(DataType.class); final DataType dataType2 = mock(DataType.class); final DataType dataType3 = mock(DataType.class); final DataType dataTypeParent0 = mock(DataType.class); final DataType dataTypeParent1 = mock(DataType.class); final DataType dataTypeParent2 = mock(DataType.class); final DataType dataTypeParent3 = mock(DataType.class); final DataType topLevelDataType = mock(DataType.class); final String topLevelName = "name"; final String topLevelType = "type"; when(topLevelDataType.getName()).thenReturn(topLevelName); when(topLevelDataType.getType()).thenReturn(topLevelType); when(dataType0.getType()).thenReturn(topLevelName); when(dataType1.getType()).thenReturn(topLevelName); when(dataType2.getType()).thenReturn(topLevelName); when(dataType3.getType()).thenReturn(topLevelType); when(dataType3.isTopLevel()).thenReturn(true); when(dataTypeStore.getTopLevelDataTypes()).thenReturn(asList(dataType0, dataType1, dataType2, dataType3)); doReturn(dataTypeParent0).when(handler).parent(dataType0); doReturn(dataTypeParent1).when(handler).parent(dataType1); doReturn(dataTypeParent2).when(handler).parent(dataType2); doReturn(dataTypeParent3).when(handler).parent(dataType3); doReturn(Optional.of(topLevelDataType)).when(handler).getClosestTopLevelDataType(dataType); doReturn(false).when(handler).isStructure(topLevelDataType); doNothing().when(handler).refreshSubDataTypes(any(), anyString()); doNothing().when(handler).refreshSubDataTypes(any()); final List<DataType> expectedDependentDataTypes = asList(topLevelDataType, dataType3, dataTypeParent0, dataTypeParent1, dataTypeParent2); final List<DataType> actualDependentDataTypes = handler.handleNestedDataTypes(dataType); verify(handler).refreshSubDataTypes(topLevelDataType, topLevelName); verify(handler).refreshSubDataTypes(dataTypeParent0); verify(handler).refreshSubDataTypes(dataType3); verify(handler).refreshSubDataTypes(dataTypeParent1); verify(handler).refreshSubDataTypes(dataTypeParent2); assertEquals(expectedDependentDataTypes, actualDependentDataTypes); } |
### Question:
ItemDefinitionCreateHandler { public ItemDefinition appendItemDefinition() { final ItemDefinition itemDefinition = new ItemDefinition(); itemDefinitions().add(itemDefinition); return itemDefinition; } @Inject ItemDefinitionCreateHandler(final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore itemDefinitionStore); ItemDefinition appendItemDefinition(); ItemDefinition insertNested(final DataType record,
final DataType reference); ItemDefinition insertSibling(final DataType record,
final DataType reference,
final CreationType creationType); }### Answer:
@Test public void testAppendItemDefinition() { when(itemDefinitionUtils.all()).thenReturn(new ArrayList<>()); final ItemDefinition itemDefinition = handler.appendItemDefinition(); assertTrue(itemDefinitionUtils.all().contains(itemDefinition)); } |
### Question:
ItemDefinitionCreateHandler { Optional<ItemDefinition> lookupAbsoluteParent(final String parentUUID) { final Optional<ItemDefinition> optionalParent = Optional.ofNullable(getIndexedItemDefinition(parentUUID)); if (optionalParent.isPresent()) { final ItemDefinition parent = optionalParent.get(); final boolean isStructure = parent.getTypeRef() == null; if (isStructure) { return Optional.of(parent); } else { return findItemDefinitionByName(parent.getTypeRef().getLocalPart()); } } return Optional.empty(); } @Inject ItemDefinitionCreateHandler(final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore itemDefinitionStore); ItemDefinition appendItemDefinition(); ItemDefinition insertNested(final DataType record,
final DataType reference); ItemDefinition insertSibling(final DataType record,
final DataType reference,
final CreationType creationType); }### Answer:
@Test public void testLookupAbsoluteParentWhenParentIsNotPresent() { final String referenceUUID = "referenceUUID"; when(itemDefinitionStore.get(referenceUUID)).thenReturn(null); final Optional<ItemDefinition> absoluteParent = handler.lookupAbsoluteParent(referenceUUID); assertFalse(absoluteParent.isPresent()); }
@Test public void testLookupAbsoluteParentWhenParentIsStructure() { final String referenceUUID = "referenceUUID"; final ItemDefinition parent = mock(ItemDefinition.class); when(parent.getTypeRef()).thenReturn(null); when(itemDefinitionStore.get(referenceUUID)).thenReturn(parent); final Optional<ItemDefinition> actualParent = handler.lookupAbsoluteParent(referenceUUID); final Optional<ItemDefinition> expectedParent = Optional.of(parent); assertEquals(expectedParent, actualParent); }
@Test public void testLookupAbsoluteParentWhenParentIsNotStructure() { final String type = "type"; final String referenceUUID = "referenceUUID"; final ItemDefinition parent = mock(ItemDefinition.class); final Optional<ItemDefinition> expectedParent = Optional.of(mock(ItemDefinition.class)); final QName qName = mock(QName.class); when(qName.getLocalPart()).thenReturn(type); when(parent.getTypeRef()).thenReturn(qName); when(itemDefinitionStore.get(referenceUUID)).thenReturn(parent); when(itemDefinitionUtils.findByName(type)).thenReturn(expectedParent); final Optional<ItemDefinition> actualParent = handler.lookupAbsoluteParent(referenceUUID); assertEquals(expectedParent, actualParent); } |
### Question:
RuleAnnotationClauseConverter { public static org.kie.dmn.model.api.RuleAnnotationClause dmnFromWB(final RuleAnnotationClause wb) { if (wb == null) { return null; } final org.kie.dmn.model.api.RuleAnnotationClause rule = new TRuleAnnotationClause(); rule.setName(wb.getName().getValue()); 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 testDmnFromWB() { final String dmnName = "name"; final Name name = new Name(dmnName); when(dmnRuleAnnotationClause.getName()).thenReturn(name); final org.kie.dmn.model.api.RuleAnnotationClause converted = RuleAnnotationClauseConverter.dmnFromWB(dmnRuleAnnotationClause); assertEquals(dmnName, converted.getName()); }
@Test public void testDmnFromWBWhenIsNull() { final org.kie.dmn.model.api.RuleAnnotationClause converted = RuleAnnotationClauseConverter.dmnFromWB(null); assertNull(converted); } |
### Question:
DataTypeStore { public DataType get(final String uuid) { return dataTypes.get(uuid); } DataType get(final String uuid); void index(final String uuid,
final DataType dataType); void clear(); int size(); List<DataType> getTopLevelDataTypes(); List<DataType> all(); void unIndex(final String uuid); }### Answer:
@Test public void testGetWhenItReturnsNull() { assertNull(store.get("456")); }
@Test public void testGetWhenItDoesNotReturnNull() { assertNotNull(store.get(uuid)); assertEquals(dataType, store.get(uuid)); } |
### Question:
DataTypeStore { public void index(final String uuid, final DataType dataType) { dataTypes.put(uuid, dataType); } DataType get(final String uuid); void index(final String uuid,
final DataType dataType); void clear(); int size(); List<DataType> getTopLevelDataTypes(); List<DataType> all(); void unIndex(final String uuid); }### Answer:
@Test public void testIndex() { assertEquals(1, store.size()); final DataType secondDataType = mock(DataType.class); final String secondUUID = "789"; store.index(secondUUID, secondDataType); assertEquals(2, store.size()); assertEquals(dataType, store.get(uuid)); assertEquals(secondDataType, store.get(secondUUID)); } |
### Question:
DataTypeStore { public void clear() { dataTypes.clear(); } DataType get(final String uuid); void index(final String uuid,
final DataType dataType); void clear(); int size(); List<DataType> getTopLevelDataTypes(); List<DataType> all(); void unIndex(final String uuid); }### Answer:
@Test public void testClear() { store.clear(); assertEquals(0, store.size()); } |
### Question:
DataTypeStore { public List<DataType> getTopLevelDataTypes() { return all() .stream() .filter(DataType::isTopLevel) .collect(Collectors.toList()); } DataType get(final String uuid); void index(final String uuid,
final DataType dataType); void clear(); int size(); List<DataType> getTopLevelDataTypes(); List<DataType> all(); void unIndex(final String uuid); }### Answer:
@Test public void testGetTopLevelDataTypes() { final String secondUUID = "789"; final String thirdUUID = "012"; final DataType secondDataType = mock(DataType.class); final DataType thirdDataType = mock(DataType.class); when(secondDataType.isTopLevel()).thenReturn(true); store.index(secondUUID, secondDataType); store.index(thirdUUID, thirdDataType); final List<DataType> topLevelDataTypes = store.getTopLevelDataTypes(); assertEquals(topLevelDataTypes, singletonList(secondDataType)); } |
### Question:
DataTypeStore { public void unIndex(final String uuid) { dataTypes.remove(uuid); subDataTypesUUID(uuid).forEach(this::unIndex); } DataType get(final String uuid); void index(final String uuid,
final DataType dataType); void clear(); int size(); List<DataType> getTopLevelDataTypes(); List<DataType> all(); void unIndex(final String uuid); }### Answer:
@Test public void testUnIndex() { final DataType dataType0 = mock(DataType.class); final DataType dataType1 = mock(DataType.class); final DataType dataType2 = mock(DataType.class); final DataType dataType3 = mock(DataType.class); final DataType dataType4 = mock(DataType.class); final DataType dataType5 = mock(DataType.class); when(dataType0.getUUID()).thenReturn("012"); when(dataType1.getUUID()).thenReturn("345"); when(dataType2.getUUID()).thenReturn("678"); when(dataType3.getUUID()).thenReturn("901"); when(dataType4.getUUID()).thenReturn("234"); when(dataType5.getUUID()).thenReturn("567"); when(dataType0.getParentUUID()).thenReturn(TOP_LEVEL_PARENT_UUID); when(dataType1.getParentUUID()).thenReturn("012"); when(dataType2.getParentUUID()).thenReturn("012"); when(dataType3.getParentUUID()).thenReturn("678"); when(dataType4.getParentUUID()).thenReturn("678"); when(dataType5.getParentUUID()).thenReturn(TOP_LEVEL_PARENT_UUID); store.index(dataType0.getUUID(), dataType0); store.index(dataType1.getUUID(), dataType1); store.index(dataType2.getUUID(), dataType2); store.index(dataType3.getUUID(), dataType3); store.index(dataType4.getUUID(), dataType4); store.index(dataType5.getUUID(), dataType5); store.unIndex("012"); assertNull(store.get("012")); assertNull(store.get("345")); assertNull(store.get("678")); assertNull(store.get("901")); assertNull(store.get("234")); assertNotNull(store.get("567")); } |
### Question:
DataTypeStore { public List<DataType> all() { return new ArrayList<>(dataTypes.values()); } DataType get(final String uuid); void index(final String uuid,
final DataType dataType); void clear(); int size(); List<DataType> getTopLevelDataTypes(); List<DataType> all(); void unIndex(final String uuid); }### Answer:
@Test public void testAll() { final DataType dataType0 = mock(DataType.class); final DataType dataType1 = mock(DataType.class); store.index("0", dataType0); store.index("1", dataType1); final List<DataType> all = store.all(); assertEquals(3, all.size()); assertTrue(all.contains(dataType)); assertTrue(all.contains(dataType0)); assertTrue(all.contains(dataType1)); } |
### Question:
DataTypeActiveRecord extends ActiveRecord<DataType> { public List<DataType> create(final DataType reference, final CreationType creationType) { return getDataTypeRecordEngine().create(getRecord(), reference, creationType); } DataTypeActiveRecord(final RecordEngine<DataType> recordEngine); List<DataType> create(final DataType reference,
final CreationType creationType); List<DataType> destroyWithoutDependentTypes(); }### Answer:
@Test public void testCreate() { final DataTypeRecordEngine engine = makeRecordEngine(); final DataType record = spy(new DataType(engine)); final DataType reference = mock(DataType.class); final List<DataType> expectedDataTypes = asList(mock(DataType.class), mock(DataType.class)); final CreationType creationType = mock(CreationType.class); doReturn(expectedDataTypes).when(engine).create(record, reference, creationType); final List<DataType> actualDataTypes = record.create(reference, creationType); assertEquals(expectedDataTypes, actualDataTypes); } |
### Question:
DataTypeActiveRecord extends ActiveRecord<DataType> { public List<DataType> destroyWithoutDependentTypes() { return getDataTypeRecordEngine().destroyWithoutDependentTypes(getRecord()); } DataTypeActiveRecord(final RecordEngine<DataType> recordEngine); List<DataType> create(final DataType reference,
final CreationType creationType); List<DataType> destroyWithoutDependentTypes(); }### Answer:
@Test public void testDestroyWithoutDependentTypes() { final DataTypeRecordEngine engine = makeRecordEngine(); final DataType record = spy(new DataType(engine)); final List<DataType> expectedDataTypes = singletonList(mock(DataType.class)); doReturn(expectedDataTypes).when(engine).destroyWithoutDependentTypes(record); final List<DataType> actualDataTypes = record.destroyWithoutDependentTypes(); assertEquals(expectedDataTypes, actualDataTypes); } |
### Question:
ItemDefinitionRecordEngine implements DataTypeRecordEngine { @PostConstruct public void init() { dataTypeCreateHandler.init(this); dataTypeDestroyHandler.init(this); dataTypeUpdateHandler.init(this); } @Inject ItemDefinitionRecordEngine(final ItemDefinitionStore itemDefinitionStore,
final ItemDefinitionDestroyHandler itemDefinitionDestroyHandler,
final ItemDefinitionUpdateHandler itemDefinitionUpdateHandler,
final ItemDefinitionCreateHandler itemDefinitionCreateHandler,
final DataTypeDestroyHandler dataTypeDestroyHandler,
final DataTypeUpdateHandler dataTypeUpdateHandler,
final DataTypeCreateHandler dataTypeCreateHandler,
final DataTypeNameValidator dataTypeNameValidator); @PostConstruct void init(); @Override List<DataType> update(final DataType dataType); @Override List<DataType> destroy(final DataType dataType); @Override List<DataType> destroyWithoutDependentTypes(final DataType dataType); @Override List<DataType> create(final DataType dataType); @Override List<DataType> create(final DataType record,
final DataType reference,
final CreationType creationType); @Override boolean isValid(final DataType dataType); void doUpdate(final DataType dataType,
final ItemDefinition itemDefinition); void doDestroy(final DataType dataType); }### Answer:
@Test public void testInit() { recordEngine.init(); verify(dataTypeDestroyHandler).init(recordEngine); verify(dataTypeUpdateHandler).init(recordEngine); } |
### Question:
ItemDefinitionRecordEngine implements DataTypeRecordEngine { @Override public List<DataType> update(final DataType dataType) { if (!dataType.isValid()) { throw new UnsupportedOperationException("An invalid Data Type cannot be updated."); } final ItemDefinition itemDefinition = itemDefinitionStore.get(dataType.getUUID()); final String itemDefinitionBeforeUpdate = itemDefinition.getName().getValue(); doUpdate(dataType, itemDefinition); return refreshDependentDataTypesFromUpdateOperation(dataType, itemDefinitionBeforeUpdate); } @Inject ItemDefinitionRecordEngine(final ItemDefinitionStore itemDefinitionStore,
final ItemDefinitionDestroyHandler itemDefinitionDestroyHandler,
final ItemDefinitionUpdateHandler itemDefinitionUpdateHandler,
final ItemDefinitionCreateHandler itemDefinitionCreateHandler,
final DataTypeDestroyHandler dataTypeDestroyHandler,
final DataTypeUpdateHandler dataTypeUpdateHandler,
final DataTypeCreateHandler dataTypeCreateHandler,
final DataTypeNameValidator dataTypeNameValidator); @PostConstruct void init(); @Override List<DataType> update(final DataType dataType); @Override List<DataType> destroy(final DataType dataType); @Override List<DataType> destroyWithoutDependentTypes(final DataType dataType); @Override List<DataType> create(final DataType dataType); @Override List<DataType> create(final DataType record,
final DataType reference,
final CreationType creationType); @Override boolean isValid(final DataType dataType); void doUpdate(final DataType dataType,
final ItemDefinition itemDefinition); void doDestroy(final DataType dataType); }### Answer:
@Test public void testUpdate() { final String uuid = "uuid"; final String nameValue = "nameValue"; final DataType dataType = mock(DataType.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); final Name name = mock(Name.class); final List<DataType> expectedDependentDataTypes = asList(mock(DataType.class), mock(DataType.class)); when(dataType.isValid()).thenReturn(true); when(dataType.getUUID()).thenReturn(uuid); when(itemDefinitionStore.get(uuid)).thenReturn(itemDefinition); when(itemDefinition.getName()).thenReturn(name); when(name.getValue()).thenReturn(nameValue); when(dataTypeUpdateHandler.refreshDependentDataTypes(dataType, nameValue)).thenReturn(expectedDependentDataTypes); final List<DataType> actualDependentDataTypes = recordEngine.update(dataType); verify(recordEngine).doUpdate(dataType, itemDefinition); assertEquals(expectedDependentDataTypes, actualDependentDataTypes); } |
### Question:
ItemDefinitionRecordEngine implements DataTypeRecordEngine { public void doUpdate(final DataType dataType, final ItemDefinition itemDefinition) { dataTypeUpdateHandler.update(dataType); itemDefinitionUpdateHandler.update(dataType, itemDefinition); } @Inject ItemDefinitionRecordEngine(final ItemDefinitionStore itemDefinitionStore,
final ItemDefinitionDestroyHandler itemDefinitionDestroyHandler,
final ItemDefinitionUpdateHandler itemDefinitionUpdateHandler,
final ItemDefinitionCreateHandler itemDefinitionCreateHandler,
final DataTypeDestroyHandler dataTypeDestroyHandler,
final DataTypeUpdateHandler dataTypeUpdateHandler,
final DataTypeCreateHandler dataTypeCreateHandler,
final DataTypeNameValidator dataTypeNameValidator); @PostConstruct void init(); @Override List<DataType> update(final DataType dataType); @Override List<DataType> destroy(final DataType dataType); @Override List<DataType> destroyWithoutDependentTypes(final DataType dataType); @Override List<DataType> create(final DataType dataType); @Override List<DataType> create(final DataType record,
final DataType reference,
final CreationType creationType); @Override boolean isValid(final DataType dataType); void doUpdate(final DataType dataType,
final ItemDefinition itemDefinition); void doDestroy(final DataType dataType); }### Answer:
@Test public void testDoUpdate() { final DataType dataType = mock(DataType.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); recordEngine.doUpdate(dataType, itemDefinition); verify(dataTypeUpdateHandler).update(dataType); verify(itemDefinitionUpdateHandler).update(dataType, itemDefinition); } |
### Question:
ItemDefinitionRecordEngine implements DataTypeRecordEngine { @Override public List<DataType> destroy(final DataType dataType) { doDestroy(dataType); return refreshDependentDataTypesFromDestroyOperation(dataType); } @Inject ItemDefinitionRecordEngine(final ItemDefinitionStore itemDefinitionStore,
final ItemDefinitionDestroyHandler itemDefinitionDestroyHandler,
final ItemDefinitionUpdateHandler itemDefinitionUpdateHandler,
final ItemDefinitionCreateHandler itemDefinitionCreateHandler,
final DataTypeDestroyHandler dataTypeDestroyHandler,
final DataTypeUpdateHandler dataTypeUpdateHandler,
final DataTypeCreateHandler dataTypeCreateHandler,
final DataTypeNameValidator dataTypeNameValidator); @PostConstruct void init(); @Override List<DataType> update(final DataType dataType); @Override List<DataType> destroy(final DataType dataType); @Override List<DataType> destroyWithoutDependentTypes(final DataType dataType); @Override List<DataType> create(final DataType dataType); @Override List<DataType> create(final DataType record,
final DataType reference,
final CreationType creationType); @Override boolean isValid(final DataType dataType); void doUpdate(final DataType dataType,
final ItemDefinition itemDefinition); void doDestroy(final DataType dataType); }### Answer:
@Test public void testDestroy() { final DataType dataType = mock(DataType.class); final List<DataType> expectedDependentDataTypes = asList(mock(DataType.class), mock(DataType.class)); when(dataTypeDestroyHandler.refreshDependentDataTypes(dataType)).thenReturn(expectedDependentDataTypes); final List<DataType> actualDependentDataTypes = recordEngine.destroy(dataType); verify(recordEngine).doDestroy(dataType); assertEquals(expectedDependentDataTypes, actualDependentDataTypes); } |
### Question:
ItemDefinitionRecordEngine implements DataTypeRecordEngine { @Override public List<DataType> destroyWithoutDependentTypes(final DataType dataType) { final List<DataType> affectedDataTypes = new ArrayList<>(); affectedDataTypes.add(dataType); doDestroy(dataType, false); return affectedDataTypes; } @Inject ItemDefinitionRecordEngine(final ItemDefinitionStore itemDefinitionStore,
final ItemDefinitionDestroyHandler itemDefinitionDestroyHandler,
final ItemDefinitionUpdateHandler itemDefinitionUpdateHandler,
final ItemDefinitionCreateHandler itemDefinitionCreateHandler,
final DataTypeDestroyHandler dataTypeDestroyHandler,
final DataTypeUpdateHandler dataTypeUpdateHandler,
final DataTypeCreateHandler dataTypeCreateHandler,
final DataTypeNameValidator dataTypeNameValidator); @PostConstruct void init(); @Override List<DataType> update(final DataType dataType); @Override List<DataType> destroy(final DataType dataType); @Override List<DataType> destroyWithoutDependentTypes(final DataType dataType); @Override List<DataType> create(final DataType dataType); @Override List<DataType> create(final DataType record,
final DataType reference,
final CreationType creationType); @Override boolean isValid(final DataType dataType); void doUpdate(final DataType dataType,
final ItemDefinition itemDefinition); void doDestroy(final DataType dataType); }### Answer:
@Test public void testDestroyWithoutDependentTypes() { final DataType dataType = mock(DataType.class); final List<DataType> dependentDataTypes = asList(mock(DataType.class), mock(DataType.class)); when(dataTypeDestroyHandler.refreshDependentDataTypes(dataType)).thenReturn(dependentDataTypes); final List<DataType> actualDependentDataTypes = recordEngine.destroyWithoutDependentTypes(dataType); final List<DataType> expectedDependentDataTypes = singletonList(dataType); verify(dataTypeDestroyHandler).destroy(dataType); verify(itemDefinitionDestroyHandler).destroy(dataType, false); assertEquals(expectedDependentDataTypes, actualDependentDataTypes); } |
### Question:
ItemDefinitionRecordEngine implements DataTypeRecordEngine { @Override public List<DataType> create(final DataType dataType) { return dataTypeCreateHandler.append(dataType, itemDefinitionCreateHandler.appendItemDefinition()); } @Inject ItemDefinitionRecordEngine(final ItemDefinitionStore itemDefinitionStore,
final ItemDefinitionDestroyHandler itemDefinitionDestroyHandler,
final ItemDefinitionUpdateHandler itemDefinitionUpdateHandler,
final ItemDefinitionCreateHandler itemDefinitionCreateHandler,
final DataTypeDestroyHandler dataTypeDestroyHandler,
final DataTypeUpdateHandler dataTypeUpdateHandler,
final DataTypeCreateHandler dataTypeCreateHandler,
final DataTypeNameValidator dataTypeNameValidator); @PostConstruct void init(); @Override List<DataType> update(final DataType dataType); @Override List<DataType> destroy(final DataType dataType); @Override List<DataType> destroyWithoutDependentTypes(final DataType dataType); @Override List<DataType> create(final DataType dataType); @Override List<DataType> create(final DataType record,
final DataType reference,
final CreationType creationType); @Override boolean isValid(final DataType dataType); void doUpdate(final DataType dataType,
final ItemDefinition itemDefinition); void doDestroy(final DataType dataType); }### Answer:
@Test public void testCreate() { final DataType dataType = mock(DataType.class); final List<DataType> expectedAffectedDataTypes = asList(mock(DataType.class), mock(DataType.class)); final ItemDefinition itemDefinition = mock(ItemDefinition.class); when(itemDefinitionCreateHandler.appendItemDefinition()).thenReturn(itemDefinition); when(dataTypeCreateHandler.append(dataType, itemDefinition)).thenReturn(expectedAffectedDataTypes); final List<DataType> actualAffectedDataTypes = recordEngine.create(dataType); assertEquals(expectedAffectedDataTypes, actualAffectedDataTypes); } |
### Question:
ItemDefinitionRecordEngine implements DataTypeRecordEngine { @Override public boolean isValid(final DataType dataType) { return dataTypeNameValidator.isValid(dataType); } @Inject ItemDefinitionRecordEngine(final ItemDefinitionStore itemDefinitionStore,
final ItemDefinitionDestroyHandler itemDefinitionDestroyHandler,
final ItemDefinitionUpdateHandler itemDefinitionUpdateHandler,
final ItemDefinitionCreateHandler itemDefinitionCreateHandler,
final DataTypeDestroyHandler dataTypeDestroyHandler,
final DataTypeUpdateHandler dataTypeUpdateHandler,
final DataTypeCreateHandler dataTypeCreateHandler,
final DataTypeNameValidator dataTypeNameValidator); @PostConstruct void init(); @Override List<DataType> update(final DataType dataType); @Override List<DataType> destroy(final DataType dataType); @Override List<DataType> destroyWithoutDependentTypes(final DataType dataType); @Override List<DataType> create(final DataType dataType); @Override List<DataType> create(final DataType record,
final DataType reference,
final CreationType creationType); @Override boolean isValid(final DataType dataType); void doUpdate(final DataType dataType,
final ItemDefinition itemDefinition); void doDestroy(final DataType dataType); }### Answer:
@Test public void testIsValidWhenItIsTrue() { final DataType dataType = mock(DataType.class); doReturn(true).when(dataTypeNameValidator).isValid(dataType); assertTrue(recordEngine.isValid(dataType)); }
@Test public void testIsValidWhenItIsFalse() { final DataType dataType = mock(DataType.class); doReturn(false).when(dataTypeNameValidator).isValid(dataType); assertFalse(recordEngine.isValid(dataType)); } |
### Question:
ItemDefinitionRecordEngine implements DataTypeRecordEngine { public void doDestroy(final DataType dataType) { doDestroy(dataType, true); } @Inject ItemDefinitionRecordEngine(final ItemDefinitionStore itemDefinitionStore,
final ItemDefinitionDestroyHandler itemDefinitionDestroyHandler,
final ItemDefinitionUpdateHandler itemDefinitionUpdateHandler,
final ItemDefinitionCreateHandler itemDefinitionCreateHandler,
final DataTypeDestroyHandler dataTypeDestroyHandler,
final DataTypeUpdateHandler dataTypeUpdateHandler,
final DataTypeCreateHandler dataTypeCreateHandler,
final DataTypeNameValidator dataTypeNameValidator); @PostConstruct void init(); @Override List<DataType> update(final DataType dataType); @Override List<DataType> destroy(final DataType dataType); @Override List<DataType> destroyWithoutDependentTypes(final DataType dataType); @Override List<DataType> create(final DataType dataType); @Override List<DataType> create(final DataType record,
final DataType reference,
final CreationType creationType); @Override boolean isValid(final DataType dataType); void doUpdate(final DataType dataType,
final ItemDefinition itemDefinition); void doDestroy(final DataType dataType); }### Answer:
@Test public void testDoDestroy() { final DataType dataType = mock(DataType.class); recordEngine.doDestroy(dataType); verify(dataTypeDestroyHandler).destroy(dataType); verify(itemDefinitionDestroyHandler).destroy(dataType, true); } |
### Question:
ExternalLinksConverter extends DMNModelInstrumentedBaseConverter { @Override protected void assignAttributes(final HierarchicalStreamReader reader, final Object parent) { superAssignAttributes(reader, parent); final ExternalLink externalLink = (ExternalLink) parent; externalLink.setName(reader.getAttribute(NAME)); externalLink.setUrl(reader.getAttribute(URL)); } ExternalLinksConverter(final XStream xstream); @Override boolean canConvert(final Class aClass); }### Answer:
@Test public void testAssignAttributes() { final ExternalLink externalLink = mock(ExternalLink.class); final HierarchicalStreamReader reader = mock(HierarchicalStreamReader.class); when(reader.getAttribute(NAME)).thenReturn(TEST_NAME); when(reader.getAttribute(URL)).thenReturn(TEST_URL); converter.assignAttributes(reader, externalLink); verify(externalLink).setName(TEST_NAME); verify(externalLink).setUrl(TEST_URL); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { @Override public void init(final Presenter presenter) { this.presenter = presenter; typeRefEditor.addValueChangeHandler(e -> currentTypeRef = e.getValue()); setKeyDownListeners(); } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testInit() { verify(dataTypeEditor).addValueChangeHandler(valueChangeHandlerCaptor.capture()); valueChangeHandlerCaptor.getValue().onValueChange(valueChangeEvent); assertEquals(view.getCurrentTypeRef(), typeRef); verify(view).setKeyDownListeners(); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { @Override protected void setKeyDownListeners() { super.setKeyDownListeners(); final Element manageButton = getManageButton(); manageButton.addEventListener(BrowserEvents.KEYDOWN, getManageButtonKeyDownEventListener(), false); final Element typeSelectorButton = getTypeSelectorButton(); typeSelectorButton.addEventListener(BrowserEvents.KEYDOWN, getTypeSelectorKeyDownEventListener(), false); } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testSetKeyDownListeners() { reset(manageButton, typeSelectorButton); view.setKeyDownListeners(); verify(popoverElement).addEventListener(BrowserEvents.KEYDOWN, keyDownCallback, false); verify(manageButton).addEventListener(BrowserEvents.KEYDOWN, managerCallback, false); verify(typeSelectorButton).addEventListener(BrowserEvents.KEYDOWN, eventListenerCallback, false); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { boolean isTabKeyPressed(final KeyboardEvent event) { return Objects.equals(event.key, TAB_KEY); } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testIsTabKeyPressed() { final KeyboardEvent keyboardEvent = mock(KeyboardEvent.class); keyboardEvent.key = TAB_KEY; boolean actual = view.isTabKeyPressed(keyboardEvent); assertTrue(actual); keyboardEvent.key = "A"; actual = view.isTabKeyPressed(keyboardEvent); assertFalse(actual); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { boolean isTab(final KeyDownEvent event) { return Objects.equals(event.getNativeKeyCode(), KeyCodes.KEY_TAB); } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testIsTab() { final KeyDownEvent keyDownEvent = mock(KeyDownEvent.class); when(keyDownEvent.getNativeKeyCode()).thenReturn(KeyCodes.KEY_TAB); final boolean actual = view.isTab(keyDownEvent); assertTrue(actual); }
@Test public void testIsNotTab() { final KeyDownEvent keyDownEvent = mock(KeyDownEvent.class); when(keyDownEvent.getNativeKeyCode()).thenReturn(KeyCodes.KEY_A); final boolean actual = view.isTab(keyDownEvent); assertFalse(actual); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { boolean isEsc(final KeyDownEvent event) { return Objects.equals(event.getNativeKeyCode(), KeyCodes.KEY_ESCAPE); } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testIsEsc() { final KeyDownEvent keyDownEvent = mock(KeyDownEvent.class); when(keyDownEvent.getNativeKeyCode()).thenReturn(KeyCodes.KEY_ESCAPE); final boolean actual = view.isEsc(keyDownEvent); assertTrue(actual); }
@Test public void testIsNotEsc() { final KeyDownEvent keyDownEvent = mock(KeyDownEvent.class); when(keyDownEvent.getNativeKeyCode()).thenReturn(KeyCodes.KEY_A); final boolean actual = view.isEsc(keyDownEvent); assertFalse(actual); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { boolean isEnter(final KeyDownEvent event) { return Objects.equals(event.getNativeKeyCode(), KeyCodes.KEY_ENTER); } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testIsEnter() { final KeyDownEvent keyDownEvent = mock(KeyDownEvent.class); when(keyDownEvent.getNativeKeyCode()).thenReturn(KeyCodes.KEY_ENTER); final boolean actual = view.isEnter(keyDownEvent); assertTrue(actual); }
@Test public void testIsNotEnter() { final KeyDownEvent keyDownEvent = mock(KeyDownEvent.class); when(keyDownEvent.getNativeKeyCode()).thenReturn(KeyCodes.KEY_A); final boolean actual = view.isEnter(keyDownEvent); assertFalse(actual); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { @Override public void setDMNModel(final DMNModelInstrumentedBase dmnModel) { typeRefEditor.setDMNModel(dmnModel); previousTypeRef = typeRefEditor.getValue(); } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testSetDMNModel() { view.setDMNModel(decision); verify(dataTypeEditor).setDMNModel(eq(decision)); } |
### Question:
ExternalLinksConverter extends DMNModelInstrumentedBaseConverter { @Override protected void writeAttributes(final HierarchicalStreamWriter writer, final Object parent) { superWriteAttributes(writer, parent); final ExternalLink externalLink = (ExternalLink) parent; writer.addAttribute(URL, externalLink.getUrl()); writer.addAttribute(NAME, externalLink.getName()); } ExternalLinksConverter(final XStream xstream); @Override boolean canConvert(final Class aClass); }### Answer:
@Test public void testWriteAttributes() { final HierarchicalStreamWriter writer = mock(HierarchicalStreamWriter.class); final ExternalLink externalLink = new ExternalLink(); externalLink.setUrl(TEST_URL); externalLink.setName(TEST_NAME); converter.writeAttributes(writer, externalLink); verify(writer).addAttribute(URL, TEST_URL); verify(writer).addAttribute(NAME, TEST_NAME); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { @Override public void initValue(final String value) { valueEditor.setValue(value); currentValue = value; previousValue = value; } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testInitValue() { view.initValue(VALUE); verify(valueEditor).setValue(eq(VALUE)); assertEquals(VALUE, view.getCurrentValue()); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { @Override public void initSelectedTypeRef(final QName typeRef) { typeRefEditor.setValue(typeRef, false); currentTypeRef = typeRef; previousTypeRef = typeRef; } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testInitSelectedTypeRef() { view.initSelectedTypeRef(typeRef); verify(dataTypeEditor).setValue(eq(typeRef), eq(false)); assertEquals(typeRef, view.getCurrentTypeRef()); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { @Override public void show(final Optional<String> popoverTitle) { valueLabel.setTextContent(presenter.getValueLabel()); getMonitor().show(popoverTitle); } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testShow() { view.show(Optional.empty()); verify(valueLabel).setTextContent(VALUE_LABEL); verify(popover).show(); } |
### Question:
ValueAndDataTypePopoverViewImpl extends AbstractPopoverViewImpl implements ValueAndDataTypePopoverView { @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueChange(final BlurEvent event) { final String value = valueEditor.getValue(); final String normalisedValue = presenter.normaliseValue(value); if (!Objects.equals(normalisedValue, value)) { valueEditor.setValue(normalisedValue); } currentValue = normalisedValue; } ValueAndDataTypePopoverViewImpl(); @Inject ValueAndDataTypePopoverViewImpl(final Input valueEditor,
final DataTypePickerWidget typeRefEditor,
final Div popoverElement,
final Div popoverContentElement,
final Span valueLabel,
final Span dataTypeLabel,
final JQueryProducer.JQuery<Popover> jQueryPopover,
final TranslationService translationService); @Override void init(final Presenter presenter); String getCurrentValue(); QName getCurrentTypeRef(); @Override void setDMNModel(final DMNModelInstrumentedBase dmnModel); @Override void initValue(final String value); @Override void initSelectedTypeRef(final QName typeRef); @Override void show(final Optional<String> popoverTitle); @Override void hide(); void hide(final boolean applyChanges); @Override void reset(); @SuppressWarnings("unused") @EventHandler("valueEditor") void onValueEditorKeyDown(final KeyDownEvent event); }### Answer:
@Test public void testOnValueChange() { when(presenter.normaliseValue(anyString())).thenAnswer(i -> i.getArguments()[0]); when(valueEditor.getValue()).thenReturn(VALUE); view.onValueChange(blurEvent); verify(presenter, never()).setValue(eq(VALUE)); assertEquals(VALUE, view.getCurrentValue()); } |
### Question:
DataTypesPage extends DMNPage { @PostConstruct public void init() { dataTypeShortcuts.init(treeList); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testInit() { page.init(); verify(dataTypeShortcuts).init(treeList); } |
### Question:
DataTypesPage extends DMNPage { @Override public void onLostFocus() { flashMessages.hideMessages(); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testOnLostFocus() { page.onLostFocus(); verify(flashMessages).hideMessages(); } |
### Question:
DataTypesPage extends DMNPage { public void reload() { loadedDMNModelNamespace = currentDMNModelNamespace(); cleanDataTypeStore(); loadDataTypes(); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testReload() { final String expected = "dmnModelNamespace"; doReturn(expected).when(page).currentDMNModelNamespace(); page.reload(); final String actual = page.getLoadedDMNModelNamespace(); verify(page).cleanDataTypeStore(); verify(page).loadDataTypes(); assertEquals(expected, actual); } |
### Question:
DataTypesPage extends DMNPage { void refreshPageView() { final HTMLDivElement pageView = getPageView(); RemoveHelper.removeChildren(pageView); pageView.appendChild(flashMessages.getElement()); pageView.appendChild(treeList.getElement()); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testRefreshPageView() { final HTMLElement flashMessagesElement = mock(HTMLElement.class); final HTMLElement treeListElement = mock(HTMLElement.class); final Element element = mock(Element.class); pageView.firstChild = element; when(pageView.removeChild(element)).then(a -> { pageView.firstChild = null; return element; }); when(flashMessages.getElement()).thenReturn(flashMessagesElement); when(treeList.getElement()).thenReturn(treeListElement); page.refreshPageView(); verify(pageView).removeChild(element); verify(pageView).appendChild(flashMessagesElement); verify(pageView).appendChild(treeListElement); } |
### Question:
DataTypesPage extends DMNPage { String currentDMNModelNamespace() { return getNamespace().map(Text::getValue).orElse(""); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testCurrentDMNModelNamespaceWhenDefinitionsIsNull() { when(dmnGraphUtils.getModelDefinitions()).thenReturn(null); final String actual = page.currentDMNModelNamespace(); final String expected = ""; assertEquals(expected, actual); }
@Test public void testCurrentDMNModelNamespace() { final Definitions definitions = mock(Definitions.class); final Text text = mock(Text.class); final String expected = "currentDMNModelNamespace"; when(text.getValue()).thenReturn(expected); when(definitions.getNamespace()).thenReturn(text); when(dmnGraphUtils.getModelDefinitions()).thenReturn(definitions); final String actual = page.currentDMNModelNamespace(); assertEquals(expected, actual); } |
### Question:
DMNDIExtensionsRegister implements DMNExtensionRegister { @Override public void registerExtensionConverters(final XStream xStream) { xStream.processAnnotations(ComponentsWidthsExtension.class); xStream.processAnnotations(ComponentWidths.class); xStream.processAnnotations(ExternalLink.class); xStream.alias(COMPONENT_WIDTH_ALIAS, Double.class); xStream.alias(EXTERNAL_LINK_ALIAS, ExternalLink.class); xStream.registerConverter(new ExternalLinksConverter(xStream)); xStream.registerConverter(new ComponentWidthsConverter(xStream)); } @Override void registerExtensionConverters(final XStream xStream); @Override void beforeMarshal(final Object o,
final QNameMap qmap); }### Answer:
@Test public void testRegisterExtensionConverters() { register.registerExtensionConverters(xStream); verify(xStream).processAnnotations(eq(ComponentsWidthsExtension.class)); verify(xStream).processAnnotations(eq(ComponentWidths.class)); verify(xStream).processAnnotations(eq(ExternalLink.class)); verify(xStream).alias(eq(COMPONENT_WIDTH_ALIAS), eq(Double.class)); verify(xStream, times(2)).registerConverter(converterCaptor.capture()); verify(xStream).alias(eq(EXTERNAL_LINK_ALIAS), eq(ExternalLink.class)); final List<Converter> values = converterCaptor.getAllValues(); assertThat(values).hasAtLeastOneElementOfType(ComponentWidthsConverter.class); assertThat(values).hasAtLeastOneElementOfType(ExternalLinksConverter.class); } |
### Question:
DataTypesPage extends DMNPage { void cleanDataTypeStore() { definitionStore.clear(); dataTypeStore.clear(); stackIndex.clear(); searchBar.reset(); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testCleanDataTypeStore() { page.cleanDataTypeStore(); verify(definitionStore).clear(); verify(dataTypeStore).clear(); verify(stackIndex).clear(); verify(searchBar).reset(); } |
### Question:
DataTypesPage extends DMNPage { void loadDataTypes() { treeList.setupItems(itemDefinitionUtils .all() .stream() .map(this::makeDataType) .collect(Collectors.toList())); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testLoadDataTypes() { final ItemDefinition itemDefinition1 = makeItem("itemDefinition1"); final ItemDefinition itemDefinition2 = makeItem("itemDefinition2"); final ItemDefinition itemDefinition3 = makeItem("itemDefinition3"); final DataType dataType1 = mock(DataType.class); final DataType dataType2 = mock(DataType.class); final DataType dataType3 = mock(DataType.class); final List<ItemDefinition> itemDefinitions = asList(itemDefinition1, itemDefinition2, itemDefinition3); when(itemDefinitionUtils.all()).thenReturn(itemDefinitions); doReturn(dataType1).when(page).makeDataType(itemDefinition1); doReturn(dataType2).when(page).makeDataType(itemDefinition2); doReturn(dataType3).when(page).makeDataType(itemDefinition3); page.loadDataTypes(); verify(treeList).setupItems(dataTypesCaptor.capture()); final List<DataType> dataTypes = dataTypesCaptor.getValue(); assertThat(dataTypes).containsExactly(dataType1, dataType2, dataType3); } |
### Question:
DataTypesPage extends DMNPage { DataType makeDataType(final ItemDefinition itemDefinition) { return dataTypeManager.from(itemDefinition).get(); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testMakeDataType() { final ItemDefinition itemDefinition = mock(ItemDefinition.class); final DataType expectedDataType = mock(DataType.class); when(dataTypeManager.from(itemDefinition)).thenReturn(dataTypeManager); when(dataTypeManager.get()).thenReturn(expectedDataType); final DataType actualDataType = page.makeDataType(itemDefinition); assertEquals(expectedDataType, actualDataType); } |
### Question:
DataTypesPage extends DMNPage { public void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event) { onFocus(); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testOnDataTypePageNavTabActiveEvent() { page.onDataTypePageNavTabActiveEvent(mock(DataTypePageTabActiveEvent.class)); verify(page).onFocus(); } |
### Question:
DataTypesPage extends DMNPage { public void enableShortcuts() { dataTypeShortcuts.setup(); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testEnableShortcuts() { page.enableShortcuts(); verify(dataTypeShortcuts).setup(); } |
### Question:
DataTypesPage extends DMNPage { public void disableShortcuts() { dataTypeShortcuts.teardown(); } @Inject DataTypesPage(final DataTypeList treeList,
final ItemDefinitionUtils itemDefinitionUtils,
final ItemDefinitionStore definitionStore,
final DataTypeStore dataTypeStore,
final DataTypeManager dataTypeManager,
final DataTypeManagerStackStore stackIndex,
final FlashMessages flashMessages,
final DataTypeSearchBar searchBar,
final DMNGraphUtils dmnGraphUtils,
final TranslationService translationService,
final DataTypeShortcuts dataTypeShortcuts,
final HTMLDivElement pageView); @PostConstruct void init(); @Override void onFocus(); @Override void onLostFocus(); void onRefreshDataTypesListWithNewItemDefinitions(final @Observes RefreshDataTypesListEvent refresh); void reload(); void onDataTypePageNavTabActiveEvent(final @Observes DataTypePageTabActiveEvent event); void enableShortcuts(); void disableShortcuts(); }### Answer:
@Test public void testDisableShortcuts() { page.disableShortcuts(); verify(dataTypeShortcuts).teardown(); } |
### Question:
DataTypeNameFormatValidator { public void ifIsValid(final DataType dataType, final Command onSuccess) { final String dataTypeName = dataType.getName(); clientServicesProxy.isValidVariableName(dataTypeName, getCallback(dataType, onSuccess)); } @Inject DataTypeNameFormatValidator(final DMNClientServicesProxy clientServicesProxy,
final Event<FlashMessage> flashMessageEvent,
final DataTypeNameIsInvalidErrorMessage nameIsInvalidErrorMessage); void ifIsValid(final DataType dataType,
final Command onSuccess); }### Answer:
@Test @SuppressWarnings("unchecked") public void testIfIsValid() { final DataType dataType = mock(DataType.class); final Command onSuccess = mock(Command.class); final String dataTypeName = "name"; when(dataType.getName()).thenReturn(dataTypeName); validator.ifIsValid(dataType, onSuccess); verify(clientServicesProxy).isValidVariableName(eq(dataTypeName), any(ServiceCallback.class)); } |
### Question:
DataTypeNameFormatValidator { ServiceCallback<Boolean> getCallback(final DataType dataType, final Command onSuccess) { return new ServiceCallback<Boolean>() { @Override public void onSuccess(final Boolean isValid) { if (isValid) { onSuccess.execute(); } else { flashMessageEvent.fire(nameIsInvalidErrorMessage.getFlashMessage(dataType)); } } @Override public void onError(final ClientRuntimeError error) { clientServicesProxy.logWarning(error); } }; } @Inject DataTypeNameFormatValidator(final DMNClientServicesProxy clientServicesProxy,
final Event<FlashMessage> flashMessageEvent,
final DataTypeNameIsInvalidErrorMessage nameIsInvalidErrorMessage); void ifIsValid(final DataType dataType,
final Command onSuccess); }### Answer:
@Test public void testGetCallbackWhenIsValid() { final DataType dataType = mock(DataType.class); final Command onSuccess = mock(Command.class); final FlashMessage flashMessage = mock(FlashMessage.class); when(nameIsInvalidErrorMessage.getFlashMessage(dataType)).thenReturn(flashMessage); validator.getCallback(dataType, onSuccess).onSuccess(true); verify(onSuccess).execute(); verify(flashMessageEvent, never()).fire(flashMessage); }
@Test public void testGetCallbackWhenIsNotValid() { final DataType dataType = mock(DataType.class); final Command onSuccess = mock(Command.class); final FlashMessage flashMessage = mock(FlashMessage.class); when(nameIsInvalidErrorMessage.getFlashMessage(dataType)).thenReturn(flashMessage); validator.getCallback(dataType, onSuccess).onSuccess(false); verify(flashMessageEvent).fire(flashMessage); verify(onSuccess, never()).execute(); } |
### Question:
DataTypeConstraint { @PostConstruct void setup() { view.init(this); disableEditMode(); } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testSetup() { dataTypeConstraint.setup(); verify(view).init(dataTypeConstraint); verify(dataTypeConstraint).disableEditMode(); } |
### Question:
DMNDIExtensionsRegister implements DMNExtensionRegister { @Override public void beforeMarshal(final Object o, final QNameMap qmap) { if (o instanceof TDefinitions) { final TDefinitions tDefinitions = (TDefinitions) o; final String prefix = tDefinitions.getPrefixForNamespaceURI(KieDMNModelInstrumentedBase.URI_KIE).orElse(KIE.getPrefix()); qmap.registerMapping(new QName(KIE.getUri(), COMPONENTS_WIDTHS_EXTENSION_ALIAS, prefix), COMPONENTS_WIDTHS_EXTENSION_ALIAS); qmap.registerMapping(new QName(KIE.getUri(), COMPONENT_WIDTHS_ALIAS, prefix), COMPONENT_WIDTHS_ALIAS); qmap.registerMapping(new QName(KIE.getUri(), COMPONENT_WIDTH_ALIAS, prefix), COMPONENT_WIDTH_ALIAS); qmap.registerMapping(new QName(KIE.getUri(), EXTERNAL_LINK_ALIAS, prefix), EXTERNAL_LINK_ALIAS); } } @Override void registerExtensionConverters(final XStream xStream); @Override void beforeMarshal(final Object o,
final QNameMap qmap); }### Answer:
@Test public void testBeforeMarshal() { final DMNModelInstrumentedBase base = mock(TDefinitions.class); when(base.getPrefixForNamespaceURI(anyString())).thenReturn(Optional.empty()); register.beforeMarshal(base, qmap); verify(qmap).registerMapping(qNameCaptor.capture(), eq(COMPONENTS_WIDTHS_EXTENSION_ALIAS)); final QName qName1 = qNameCaptor.getValue(); assertThat(qName1.getNamespaceURI()).isEqualTo(KIE.getUri()); assertThat(qName1.getLocalPart()).isEqualTo(COMPONENTS_WIDTHS_EXTENSION_ALIAS); assertThat(qName1.getPrefix()).isEqualTo(KIE.getPrefix()); verify(qmap).registerMapping(qNameCaptor.capture(), eq(COMPONENT_WIDTHS_ALIAS)); final QName qName2 = qNameCaptor.getValue(); assertThat(qName2.getNamespaceURI()).isEqualTo(KIE.getUri()); assertThat(qName2.getLocalPart()).isEqualTo(COMPONENT_WIDTHS_ALIAS); assertThat(qName2.getPrefix()).isEqualTo(KIE.getPrefix()); verify(qmap).registerMapping(qNameCaptor.capture(), eq(COMPONENT_WIDTH_ALIAS)); final QName qName3 = qNameCaptor.getValue(); assertThat(qName3.getNamespaceURI()).isEqualTo(KIE.getUri()); assertThat(qName3.getLocalPart()).isEqualTo(COMPONENT_WIDTH_ALIAS); assertThat(qName3.getPrefix()).isEqualTo(KIE.getPrefix()); verify(qmap).registerMapping(qNameCaptor.capture(), eq(EXTERNAL_LINK_ALIAS)); final QName qName4 = qNameCaptor.getValue(); assertThat(qName4.getNamespaceURI()).isEqualTo(KIE.getUri()); assertThat(qName4.getLocalPart()).isEqualTo(EXTERNAL_LINK_ALIAS); assertThat(qName4.getPrefix()).isEqualTo(KIE.getPrefix()); } |
### Question:
DataTypeConstraint { public void init(final DataTypeListItem listItem) { this.listItem = listItem; this.constraintValue = listItem.getDataType().getConstraint(); this.constraintType = listItem.getDataType().getConstraintType(); refreshView(); } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testInit() { final DataTypeListItem expectedListItem = mock(DataTypeListItem.class); final DataType datatype = mock(DataType.class); final String expectedConstraint = "constraint"; final ConstraintType expectedType = mock(ConstraintType.class); when(expectedListItem.getDataType()).thenReturn(datatype); when(datatype.getConstraint()).thenReturn(expectedConstraint); when(datatype.getConstraintType()).thenReturn(expectedType); dataTypeConstraint.init(expectedListItem); final DataTypeListItem actualListItem = dataTypeConstraint.getListItem(); final String actualConstraint = dataTypeConstraint.getValue(); final ConstraintType actualType = dataTypeConstraint.getConstraintType(); assertEquals(expectedType, actualType); assertEquals(expectedListItem, actualListItem); assertEquals(expectedConstraint, actualConstraint); verify(dataTypeConstraint).refreshView(); } |
### Question:
DataTypeConstraint { public HTMLElement getElement() { return view.getElement(); } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testGetElement() { final HTMLElement expectedElement = mock(HTMLElement.class); when(view.getElement()).thenReturn(expectedElement); final HTMLElement actualElement = dataTypeConstraint.getElement(); assertEquals(expectedElement, actualElement); } |
### Question:
DataTypeConstraint { public void enableEditMode() { isEditModeEnabled = true; view.showAnchor(); } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testEnableEditMode() { dataTypeConstraint.enableEditMode(); assertTrue(dataTypeConstraint.isEditModeEnabled()); verify(view).showAnchor(); } |
### Question:
DataTypeConstraint { public void disableEditMode() { isEditModeEnabled = false; view.hideAnchor(); } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testDisableEditMode() { dataTypeConstraint.disableEditMode(); assertFalse(dataTypeConstraint.isEditModeEnabled()); verify(view).hideAnchor(); } |
### Question:
DataTypeConstraint { void openModal() { constraintModal().load(getListItem().getType(), getValue(), getConstraintType()); constraintModal().show(getOnShowConsumer()); } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testOpenModal() { final DataTypeListItem listItem = mock(DataTypeListItem.class); final String constraint = "1,2,3"; final String type = "string"; final BiConsumer<String, ConstraintType> onShowConsumer = (s, c) -> { }; doReturn(listItem).when(dataTypeConstraint).getListItem(); doReturn(constraint).when(dataTypeConstraint).getValue(); doReturn(onShowConsumer).when(dataTypeConstraint).getOnShowConsumer(); when(listItem.getType()).thenReturn(type); dataTypeConstraint.openModal(); constraintModal.load(type, constraint, ENUMERATION); constraintModal.show(onShowConsumer); } |
### Question:
DataTypeConstraint { BiConsumer<String, ConstraintType> getOnShowConsumer() { return (newConstraintValue, newConstraintType) -> { setConstraint(newConstraintValue, newConstraintType); refreshView(); }; } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testGetOnShowConsumer() { final String expectedConstraint = "1,2,3"; final ConstraintType expectedConstraintType = ENUMERATION; dataTypeConstraint.getOnShowConsumer().accept(expectedConstraint, ENUMERATION); final String actualConstraint = dataTypeConstraint.getValue(); final ConstraintType actualConstraintType = dataTypeConstraint.getConstraintType(); assertEquals(expectedConstraint, actualConstraint); assertEquals(expectedConstraintType, actualConstraintType); verify(dataTypeConstraint).refreshView(); } |
### Question:
DataTypeConstraint { public void disable() { setConstraint(NONE, ConstraintType.NONE); view.disable(); } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testDisable() { dataTypeConstraint.disable(); final String actualConstraint = dataTypeConstraint.getValue(); final ConstraintType actualConstraintType = dataTypeConstraint.getConstraintType(); assertEquals(DataTypeConstraint.NONE, actualConstraint); assertEquals(ConstraintType.NONE, actualConstraintType); verify(view).disable(); } |
### Question:
DataTypeConstraint { public void enable() { view.enable(); } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testEnable() { dataTypeConstraint.enable(); verify(view).enable(); } |
### Question:
DataTypeConstraint { DataTypeConstraintModal getConstraintModal() { return constraintModal; } @Inject DataTypeConstraint(final View view,
final ManagedInstance<DataTypeConstraintModal> constraintModalManagedInstance); void init(final DataTypeListItem listItem); String getValue(); ConstraintType getConstraintType(); HTMLElement getElement(); void enableEditMode(); void disableEditMode(); void refreshView(); void disable(); void enable(); }### Answer:
@Test public void testGetConstraintModal() { assertNull(dataTypeConstraint.getConstraintModal()); final DataTypeConstraintModal firstCallResult = dataTypeConstraint.constraintModal(); final DataTypeConstraintModal secondCallResult = dataTypeConstraint.constraintModal(); assertNotNull(dataTypeConstraint.getConstraintModal()); assertSame(dataTypeConstraint.getConstraintModal(), firstCallResult); assertSame(dataTypeConstraint.getConstraintModal(), secondCallResult); } |
### Question:
DataTypeConstraintModalView implements DataTypeConstraintModal.View { @PostConstruct public void init() { setupSelectPicker(); setupSelectPickerOnChangeHandler(); setupEmptyContainer(); } @Inject DataTypeConstraintModalView(final HTMLDivElement header,
final HTMLDivElement body,
final HTMLDivElement footer,
final HTMLDivElement componentContainer,
final HTMLButtonElement okButton,
final HTMLButtonElement cancelButton,
final HTMLAnchorElement clearAllAnchor,
final @Named("span") HTMLElement type,
final HTMLDivElement selectConstraint,
final HTMLDivElement constraintWarningMessage,
final HTMLButtonElement closeConstraintWarningMessage); @PostConstruct void init(); @Override void init(final DataTypeConstraintModal presenter); @Override String getHeader(); @Override HTMLElement getBody(); @Override HTMLElement getFooter(); @EventHandler("ok-button") void onOkButtonClick(final ClickEvent e); @EventHandler("cancel-button") void onCancelButtonClick(final ClickEvent e); @EventHandler("clear-all-anchor") void onClearAllAnchorClick(final ClickEvent e); @EventHandler("close-constraint-warning-message") void onCloseConstraintWarningClick(final ClickEvent e); @Override void showConstraintWarningMessage(); @Override void setType(final String type); @Override void setupEmptyContainer(); @Override void loadComponent(final ConstraintType constraintType); @Override void onShow(); @Override void setupOnHideHandler(final Command handler); @Override void enableOkButton(); @Override void disableOkButton(); }### Answer:
@Test public void testInit() { doNothing().when(view).setupSelectPicker(); doNothing().when(view).setupSelectPickerOnChangeHandler(); doNothing().when(view).setupEmptyContainer(); view.init(); verify(view).setupSelectPicker(); verify(view).setupSelectPickerOnChangeHandler(); verify(view).setupEmptyContainer(); } |
### Question:
PointUtils { public static void convertToAbsoluteBounds(final Node<?, ?> targetNode) { convertBounds(targetNode, (base, delta) -> base + delta); } private PointUtils(); static org.kie.dmn.model.api.dmndi.Point point2dToDMNDIPoint(org.kie.workbench.common.stunner.core.graph.content.view.Point2D point2d); static org.kie.workbench.common.stunner.core.graph.content.view.Point2D dmndiPointToPoint2D(org.kie.dmn.model.api.dmndi.Point dmndiPoint); static void convertToAbsoluteBounds(final Node<?, ?> targetNode); static void convertToRelativeBounds(final Node<?, ?> targetNode); static double xOfShape(final DMNShape shape); static double yOfShape(final DMNShape shape); static double widthOfShape(final DMNShape shape); static double heightOfShape(final DMNShape shape); static Bound upperLeftBound(final View view); static Bound lowerRightBound(final View view); static double xOfBound(final Bound bound); static double yOfBound(final Bound bound); }### Answer:
@Test public void testConvertToAbsoluteBoundsWhenChild() { final Node<View, Edge> parent = new NodeImpl<>(UUID.uuid()); final View parentView = new ViewImpl<>(new Decision(), Bounds.create(100, 200, 1000, 2000)); parent.setContent(parentView); final Node<View, Edge> child = new NodeImpl<>(UUID.uuid()); final View childView = new ViewImpl<>(new Decision(), Bounds.create(10, 20, 50, 60)); child.setContent(childView); final Edge<Child, Node> edge = new EdgeImpl<>(UUID.uuid()); edge.setContent(new Child()); edge.setSourceNode(parent); edge.setTargetNode(child); parent.getOutEdges().add(edge); child.getInEdges().add(edge); PointUtils.convertToAbsoluteBounds(child); final Bound ulBound = child.getContent().getBounds().getUpperLeft(); final Bound lrBound = child.getContent().getBounds().getLowerRight(); assertThat(ulBound.getX()).isEqualTo(110); assertThat(ulBound.getY()).isEqualTo(220); assertThat(lrBound.getX()).isEqualTo(150); assertThat(lrBound.getY()).isEqualTo(260); }
@Test public void testConvertToAbsoluteBoundsWhenNotChild() { final Node<View, ?> node = new NodeImpl<>(UUID.uuid()); final View nodeView = new ViewImpl<>(new Decision(), Bounds.create(10, 20, 50, 60)); node.setContent(nodeView); PointUtils.convertToAbsoluteBounds(node); final Bound ulBound = node.getContent().getBounds().getUpperLeft(); final Bound lrBound = node.getContent().getBounds().getLowerRight(); assertThat(ulBound.getX()).isEqualTo(10); assertThat(ulBound.getY()).isEqualTo(20); assertThat(lrBound.getX()).isEqualTo(50); assertThat(lrBound.getY()).isEqualTo(60); } |
### Question:
DataTypeConstraintModalView implements DataTypeConstraintModal.View { @Override public String getHeader() { return header.textContent; } @Inject DataTypeConstraintModalView(final HTMLDivElement header,
final HTMLDivElement body,
final HTMLDivElement footer,
final HTMLDivElement componentContainer,
final HTMLButtonElement okButton,
final HTMLButtonElement cancelButton,
final HTMLAnchorElement clearAllAnchor,
final @Named("span") HTMLElement type,
final HTMLDivElement selectConstraint,
final HTMLDivElement constraintWarningMessage,
final HTMLButtonElement closeConstraintWarningMessage); @PostConstruct void init(); @Override void init(final DataTypeConstraintModal presenter); @Override String getHeader(); @Override HTMLElement getBody(); @Override HTMLElement getFooter(); @EventHandler("ok-button") void onOkButtonClick(final ClickEvent e); @EventHandler("cancel-button") void onCancelButtonClick(final ClickEvent e); @EventHandler("clear-all-anchor") void onClearAllAnchorClick(final ClickEvent e); @EventHandler("close-constraint-warning-message") void onCloseConstraintWarningClick(final ClickEvent e); @Override void showConstraintWarningMessage(); @Override void setType(final String type); @Override void setupEmptyContainer(); @Override void loadComponent(final ConstraintType constraintType); @Override void onShow(); @Override void setupOnHideHandler(final Command handler); @Override void enableOkButton(); @Override void disableOkButton(); }### Answer:
@Test public void testGetHeader() { final String expectedHeader = "header"; header.textContent = expectedHeader; final String actualHeader = view.getHeader(); assertEquals(expectedHeader, actualHeader); } |
### Question:
DataTypeConstraintModalView implements DataTypeConstraintModal.View { @Override public HTMLElement getBody() { return body; } @Inject DataTypeConstraintModalView(final HTMLDivElement header,
final HTMLDivElement body,
final HTMLDivElement footer,
final HTMLDivElement componentContainer,
final HTMLButtonElement okButton,
final HTMLButtonElement cancelButton,
final HTMLAnchorElement clearAllAnchor,
final @Named("span") HTMLElement type,
final HTMLDivElement selectConstraint,
final HTMLDivElement constraintWarningMessage,
final HTMLButtonElement closeConstraintWarningMessage); @PostConstruct void init(); @Override void init(final DataTypeConstraintModal presenter); @Override String getHeader(); @Override HTMLElement getBody(); @Override HTMLElement getFooter(); @EventHandler("ok-button") void onOkButtonClick(final ClickEvent e); @EventHandler("cancel-button") void onCancelButtonClick(final ClickEvent e); @EventHandler("clear-all-anchor") void onClearAllAnchorClick(final ClickEvent e); @EventHandler("close-constraint-warning-message") void onCloseConstraintWarningClick(final ClickEvent e); @Override void showConstraintWarningMessage(); @Override void setType(final String type); @Override void setupEmptyContainer(); @Override void loadComponent(final ConstraintType constraintType); @Override void onShow(); @Override void setupOnHideHandler(final Command handler); @Override void enableOkButton(); @Override void disableOkButton(); }### Answer:
@Test public void testGetBody() { assertEquals(body, view.getBody()); } |
### Question:
DataTypeConstraintModalView implements DataTypeConstraintModal.View { @Override public HTMLElement getFooter() { return footer; } @Inject DataTypeConstraintModalView(final HTMLDivElement header,
final HTMLDivElement body,
final HTMLDivElement footer,
final HTMLDivElement componentContainer,
final HTMLButtonElement okButton,
final HTMLButtonElement cancelButton,
final HTMLAnchorElement clearAllAnchor,
final @Named("span") HTMLElement type,
final HTMLDivElement selectConstraint,
final HTMLDivElement constraintWarningMessage,
final HTMLButtonElement closeConstraintWarningMessage); @PostConstruct void init(); @Override void init(final DataTypeConstraintModal presenter); @Override String getHeader(); @Override HTMLElement getBody(); @Override HTMLElement getFooter(); @EventHandler("ok-button") void onOkButtonClick(final ClickEvent e); @EventHandler("cancel-button") void onCancelButtonClick(final ClickEvent e); @EventHandler("clear-all-anchor") void onClearAllAnchorClick(final ClickEvent e); @EventHandler("close-constraint-warning-message") void onCloseConstraintWarningClick(final ClickEvent e); @Override void showConstraintWarningMessage(); @Override void setType(final String type); @Override void setupEmptyContainer(); @Override void loadComponent(final ConstraintType constraintType); @Override void onShow(); @Override void setupOnHideHandler(final Command handler); @Override void enableOkButton(); @Override void disableOkButton(); }### Answer:
@Test public void testGetFooter() { assertEquals(footer, view.getFooter()); } |
### Question:
DataTypeConstraintModalView implements DataTypeConstraintModal.View { @EventHandler("ok-button") public void onOkButtonClick(final ClickEvent e) { presenter.save(); } @Inject DataTypeConstraintModalView(final HTMLDivElement header,
final HTMLDivElement body,
final HTMLDivElement footer,
final HTMLDivElement componentContainer,
final HTMLButtonElement okButton,
final HTMLButtonElement cancelButton,
final HTMLAnchorElement clearAllAnchor,
final @Named("span") HTMLElement type,
final HTMLDivElement selectConstraint,
final HTMLDivElement constraintWarningMessage,
final HTMLButtonElement closeConstraintWarningMessage); @PostConstruct void init(); @Override void init(final DataTypeConstraintModal presenter); @Override String getHeader(); @Override HTMLElement getBody(); @Override HTMLElement getFooter(); @EventHandler("ok-button") void onOkButtonClick(final ClickEvent e); @EventHandler("cancel-button") void onCancelButtonClick(final ClickEvent e); @EventHandler("clear-all-anchor") void onClearAllAnchorClick(final ClickEvent e); @EventHandler("close-constraint-warning-message") void onCloseConstraintWarningClick(final ClickEvent e); @Override void showConstraintWarningMessage(); @Override void setType(final String type); @Override void setupEmptyContainer(); @Override void loadComponent(final ConstraintType constraintType); @Override void onShow(); @Override void setupOnHideHandler(final Command handler); @Override void enableOkButton(); @Override void disableOkButton(); }### Answer:
@Test public void testOnOkButtonClick() { view.onOkButtonClick(mock(ClickEvent.class)); verify(presenter).save(); } |
### Question:
DataTypeConstraintModalView implements DataTypeConstraintModal.View { @EventHandler("cancel-button") public void onCancelButtonClick(final ClickEvent e) { presenter.hide(); } @Inject DataTypeConstraintModalView(final HTMLDivElement header,
final HTMLDivElement body,
final HTMLDivElement footer,
final HTMLDivElement componentContainer,
final HTMLButtonElement okButton,
final HTMLButtonElement cancelButton,
final HTMLAnchorElement clearAllAnchor,
final @Named("span") HTMLElement type,
final HTMLDivElement selectConstraint,
final HTMLDivElement constraintWarningMessage,
final HTMLButtonElement closeConstraintWarningMessage); @PostConstruct void init(); @Override void init(final DataTypeConstraintModal presenter); @Override String getHeader(); @Override HTMLElement getBody(); @Override HTMLElement getFooter(); @EventHandler("ok-button") void onOkButtonClick(final ClickEvent e); @EventHandler("cancel-button") void onCancelButtonClick(final ClickEvent e); @EventHandler("clear-all-anchor") void onClearAllAnchorClick(final ClickEvent e); @EventHandler("close-constraint-warning-message") void onCloseConstraintWarningClick(final ClickEvent e); @Override void showConstraintWarningMessage(); @Override void setType(final String type); @Override void setupEmptyContainer(); @Override void loadComponent(final ConstraintType constraintType); @Override void onShow(); @Override void setupOnHideHandler(final Command handler); @Override void enableOkButton(); @Override void disableOkButton(); }### Answer:
@Test public void testOnCancelButtonClick() { view.onCancelButtonClick(mock(ClickEvent.class)); verify(presenter).hide(); } |
### Question:
DataTypeConstraintModalView implements DataTypeConstraintModal.View { @EventHandler("clear-all-anchor") public void onClearAllAnchorClick(final ClickEvent e) { presenter.clearAll(); } @Inject DataTypeConstraintModalView(final HTMLDivElement header,
final HTMLDivElement body,
final HTMLDivElement footer,
final HTMLDivElement componentContainer,
final HTMLButtonElement okButton,
final HTMLButtonElement cancelButton,
final HTMLAnchorElement clearAllAnchor,
final @Named("span") HTMLElement type,
final HTMLDivElement selectConstraint,
final HTMLDivElement constraintWarningMessage,
final HTMLButtonElement closeConstraintWarningMessage); @PostConstruct void init(); @Override void init(final DataTypeConstraintModal presenter); @Override String getHeader(); @Override HTMLElement getBody(); @Override HTMLElement getFooter(); @EventHandler("ok-button") void onOkButtonClick(final ClickEvent e); @EventHandler("cancel-button") void onCancelButtonClick(final ClickEvent e); @EventHandler("clear-all-anchor") void onClearAllAnchorClick(final ClickEvent e); @EventHandler("close-constraint-warning-message") void onCloseConstraintWarningClick(final ClickEvent e); @Override void showConstraintWarningMessage(); @Override void setType(final String type); @Override void setupEmptyContainer(); @Override void loadComponent(final ConstraintType constraintType); @Override void onShow(); @Override void setupOnHideHandler(final Command handler); @Override void enableOkButton(); @Override void disableOkButton(); }### Answer:
@Test public void testOnClearAllAnchorClick() { view.onClearAllAnchorClick(mock(ClickEvent.class)); verify(presenter).clearAll(); } |
### Question:
DataTypeConstraintModalView implements DataTypeConstraintModal.View { @Override public void setType(final String type) { this.type.textContent = type; } @Inject DataTypeConstraintModalView(final HTMLDivElement header,
final HTMLDivElement body,
final HTMLDivElement footer,
final HTMLDivElement componentContainer,
final HTMLButtonElement okButton,
final HTMLButtonElement cancelButton,
final HTMLAnchorElement clearAllAnchor,
final @Named("span") HTMLElement type,
final HTMLDivElement selectConstraint,
final HTMLDivElement constraintWarningMessage,
final HTMLButtonElement closeConstraintWarningMessage); @PostConstruct void init(); @Override void init(final DataTypeConstraintModal presenter); @Override String getHeader(); @Override HTMLElement getBody(); @Override HTMLElement getFooter(); @EventHandler("ok-button") void onOkButtonClick(final ClickEvent e); @EventHandler("cancel-button") void onCancelButtonClick(final ClickEvent e); @EventHandler("clear-all-anchor") void onClearAllAnchorClick(final ClickEvent e); @EventHandler("close-constraint-warning-message") void onCloseConstraintWarningClick(final ClickEvent e); @Override void showConstraintWarningMessage(); @Override void setType(final String type); @Override void setupEmptyContainer(); @Override void loadComponent(final ConstraintType constraintType); @Override void onShow(); @Override void setupOnHideHandler(final Command handler); @Override void enableOkButton(); @Override void disableOkButton(); }### Answer:
@Test public void testSetType() { final String expectedText = "type"; this.type.textContent = "something"; view.setType(expectedText); final String actualText = this.type.textContent; assertEquals(expectedText, actualText); } |
### Question:
DataTypeConstraintModalView implements DataTypeConstraintModal.View { @Override public void setupEmptyContainer() { RemoveHelper.removeChildren(componentContainer); componentContainer.appendChild(selectConstraint); } @Inject DataTypeConstraintModalView(final HTMLDivElement header,
final HTMLDivElement body,
final HTMLDivElement footer,
final HTMLDivElement componentContainer,
final HTMLButtonElement okButton,
final HTMLButtonElement cancelButton,
final HTMLAnchorElement clearAllAnchor,
final @Named("span") HTMLElement type,
final HTMLDivElement selectConstraint,
final HTMLDivElement constraintWarningMessage,
final HTMLButtonElement closeConstraintWarningMessage); @PostConstruct void init(); @Override void init(final DataTypeConstraintModal presenter); @Override String getHeader(); @Override HTMLElement getBody(); @Override HTMLElement getFooter(); @EventHandler("ok-button") void onOkButtonClick(final ClickEvent e); @EventHandler("cancel-button") void onCancelButtonClick(final ClickEvent e); @EventHandler("clear-all-anchor") void onClearAllAnchorClick(final ClickEvent e); @EventHandler("close-constraint-warning-message") void onCloseConstraintWarningClick(final ClickEvent e); @Override void showConstraintWarningMessage(); @Override void setType(final String type); @Override void setupEmptyContainer(); @Override void loadComponent(final ConstraintType constraintType); @Override void onShow(); @Override void setupOnHideHandler(final Command handler); @Override void enableOkButton(); @Override void disableOkButton(); }### Answer:
@Test public void testSetupEmptyContainer() { final Element element = mock(Element.class); componentContainer.firstChild = element; when(componentContainer.removeChild(element)).then(a -> { componentContainer.firstChild = null; return element; }); view.setupEmptyContainer(); verify(componentContainer).removeChild(element); verify(componentContainer).appendChild(selectConstraint); } |
### Question:
DataTypeConstraintModalView implements DataTypeConstraintModal.View { @Override public void loadComponent(final ConstraintType constraintType) { presenter.setupComponent(constraintType); RemoveHelper.removeChildren(componentContainer); componentContainer.appendChild(presenter.getCurrentComponent().getElement()); } @Inject DataTypeConstraintModalView(final HTMLDivElement header,
final HTMLDivElement body,
final HTMLDivElement footer,
final HTMLDivElement componentContainer,
final HTMLButtonElement okButton,
final HTMLButtonElement cancelButton,
final HTMLAnchorElement clearAllAnchor,
final @Named("span") HTMLElement type,
final HTMLDivElement selectConstraint,
final HTMLDivElement constraintWarningMessage,
final HTMLButtonElement closeConstraintWarningMessage); @PostConstruct void init(); @Override void init(final DataTypeConstraintModal presenter); @Override String getHeader(); @Override HTMLElement getBody(); @Override HTMLElement getFooter(); @EventHandler("ok-button") void onOkButtonClick(final ClickEvent e); @EventHandler("cancel-button") void onCancelButtonClick(final ClickEvent e); @EventHandler("clear-all-anchor") void onClearAllAnchorClick(final ClickEvent e); @EventHandler("close-constraint-warning-message") void onCloseConstraintWarningClick(final ClickEvent e); @Override void showConstraintWarningMessage(); @Override void setType(final String type); @Override void setupEmptyContainer(); @Override void loadComponent(final ConstraintType constraintType); @Override void onShow(); @Override void setupOnHideHandler(final Command handler); @Override void enableOkButton(); @Override void disableOkButton(); }### Answer:
@Test public void testLoadComponent() { final ConstraintType constraintType = ENUMERATION; final DataTypeConstraintComponent constrainComponent = mock(DataTypeConstraintComponent.class); final Element element = mock(Element.class); final Element previous = mock(Element.class); componentContainer.firstChild = previous; when(presenter.getCurrentComponent()).thenReturn(constrainComponent); when(constrainComponent.getElement()).thenReturn(element); when(componentContainer.removeChild(previous)).then(a -> { componentContainer.firstChild = null; return element; }); view.loadComponent(constraintType); verify(componentContainer).removeChild(previous); verify(presenter).setupComponent(constraintType); verify(componentContainer).appendChild(element); } |
### Question:
DataTypeConstraintModalView implements DataTypeConstraintModal.View { void setupSelectPicker() { triggerPickerAction(getSelectPicker(), "refresh"); } @Inject DataTypeConstraintModalView(final HTMLDivElement header,
final HTMLDivElement body,
final HTMLDivElement footer,
final HTMLDivElement componentContainer,
final HTMLButtonElement okButton,
final HTMLButtonElement cancelButton,
final HTMLAnchorElement clearAllAnchor,
final @Named("span") HTMLElement type,
final HTMLDivElement selectConstraint,
final HTMLDivElement constraintWarningMessage,
final HTMLButtonElement closeConstraintWarningMessage); @PostConstruct void init(); @Override void init(final DataTypeConstraintModal presenter); @Override String getHeader(); @Override HTMLElement getBody(); @Override HTMLElement getFooter(); @EventHandler("ok-button") void onOkButtonClick(final ClickEvent e); @EventHandler("cancel-button") void onCancelButtonClick(final ClickEvent e); @EventHandler("clear-all-anchor") void onClearAllAnchorClick(final ClickEvent e); @EventHandler("close-constraint-warning-message") void onCloseConstraintWarningClick(final ClickEvent e); @Override void showConstraintWarningMessage(); @Override void setType(final String type); @Override void setupEmptyContainer(); @Override void loadComponent(final ConstraintType constraintType); @Override void onShow(); @Override void setupOnHideHandler(final Command handler); @Override void enableOkButton(); @Override void disableOkButton(); }### Answer:
@Test public void testSetupSelectPicker() { final Element element = mock(Element.class); doReturn(element).when(view).getSelectPicker(); doNothing().when(view).triggerPickerAction(any(), anyString()); view.setupSelectPicker(); verify(view).triggerPickerAction(element, "refresh"); } |
### Question:
DataTypeConstraintModalView implements DataTypeConstraintModal.View { void setupSelectPickerOnChangeHandler() { setupOnChangeHandler(getSelectPicker()); } @Inject DataTypeConstraintModalView(final HTMLDivElement header,
final HTMLDivElement body,
final HTMLDivElement footer,
final HTMLDivElement componentContainer,
final HTMLButtonElement okButton,
final HTMLButtonElement cancelButton,
final HTMLAnchorElement clearAllAnchor,
final @Named("span") HTMLElement type,
final HTMLDivElement selectConstraint,
final HTMLDivElement constraintWarningMessage,
final HTMLButtonElement closeConstraintWarningMessage); @PostConstruct void init(); @Override void init(final DataTypeConstraintModal presenter); @Override String getHeader(); @Override HTMLElement getBody(); @Override HTMLElement getFooter(); @EventHandler("ok-button") void onOkButtonClick(final ClickEvent e); @EventHandler("cancel-button") void onCancelButtonClick(final ClickEvent e); @EventHandler("clear-all-anchor") void onClearAllAnchorClick(final ClickEvent e); @EventHandler("close-constraint-warning-message") void onCloseConstraintWarningClick(final ClickEvent e); @Override void showConstraintWarningMessage(); @Override void setType(final String type); @Override void setupEmptyContainer(); @Override void loadComponent(final ConstraintType constraintType); @Override void onShow(); @Override void setupOnHideHandler(final Command handler); @Override void enableOkButton(); @Override void disableOkButton(); }### Answer:
@Test public void testSetupSelectPickerOnChangeHandler() { final Element element = mock(Element.class); doReturn(element).when(view).getSelectPicker(); doNothing().when(view).setupOnChangeHandler(any()); view.setupSelectPickerOnChangeHandler(); verify(view).setupOnChangeHandler(element); } |
### Question:
DataTypeConstraintModalView implements DataTypeConstraintModal.View { Element getSelectPicker() { return body.querySelector(".selectpicker"); } @Inject DataTypeConstraintModalView(final HTMLDivElement header,
final HTMLDivElement body,
final HTMLDivElement footer,
final HTMLDivElement componentContainer,
final HTMLButtonElement okButton,
final HTMLButtonElement cancelButton,
final HTMLAnchorElement clearAllAnchor,
final @Named("span") HTMLElement type,
final HTMLDivElement selectConstraint,
final HTMLDivElement constraintWarningMessage,
final HTMLButtonElement closeConstraintWarningMessage); @PostConstruct void init(); @Override void init(final DataTypeConstraintModal presenter); @Override String getHeader(); @Override HTMLElement getBody(); @Override HTMLElement getFooter(); @EventHandler("ok-button") void onOkButtonClick(final ClickEvent e); @EventHandler("cancel-button") void onCancelButtonClick(final ClickEvent e); @EventHandler("clear-all-anchor") void onClearAllAnchorClick(final ClickEvent e); @EventHandler("close-constraint-warning-message") void onCloseConstraintWarningClick(final ClickEvent e); @Override void showConstraintWarningMessage(); @Override void setType(final String type); @Override void setupEmptyContainer(); @Override void loadComponent(final ConstraintType constraintType); @Override void onShow(); @Override void setupOnHideHandler(final Command handler); @Override void enableOkButton(); @Override void disableOkButton(); }### Answer:
@Test public void testGetSelectPicker() { final HTMLElement expectedSelect = mock(HTMLElement.class); when(body.querySelector(".selectpicker")).thenReturn(expectedSelect); final Element actualSelect = view.getSelectPicker(); assertEquals(expectedSelect, actualSelect); } |
### Question:
DataTypeConstraintModalView implements DataTypeConstraintModal.View { @EventHandler("close-constraint-warning-message") public void onCloseConstraintWarningClick(final ClickEvent e) { hide(constraintWarningMessage); } @Inject DataTypeConstraintModalView(final HTMLDivElement header,
final HTMLDivElement body,
final HTMLDivElement footer,
final HTMLDivElement componentContainer,
final HTMLButtonElement okButton,
final HTMLButtonElement cancelButton,
final HTMLAnchorElement clearAllAnchor,
final @Named("span") HTMLElement type,
final HTMLDivElement selectConstraint,
final HTMLDivElement constraintWarningMessage,
final HTMLButtonElement closeConstraintWarningMessage); @PostConstruct void init(); @Override void init(final DataTypeConstraintModal presenter); @Override String getHeader(); @Override HTMLElement getBody(); @Override HTMLElement getFooter(); @EventHandler("ok-button") void onOkButtonClick(final ClickEvent e); @EventHandler("cancel-button") void onCancelButtonClick(final ClickEvent e); @EventHandler("clear-all-anchor") void onClearAllAnchorClick(final ClickEvent e); @EventHandler("close-constraint-warning-message") void onCloseConstraintWarningClick(final ClickEvent e); @Override void showConstraintWarningMessage(); @Override void setType(final String type); @Override void setupEmptyContainer(); @Override void loadComponent(final ConstraintType constraintType); @Override void onShow(); @Override void setupOnHideHandler(final Command handler); @Override void enableOkButton(); @Override void disableOkButton(); }### Answer:
@Test public void testOnCloseConstraintWarningClick() { constraintWarningMessage.classList = mock(DOMTokenList.class); view.onCloseConstraintWarningClick(mock(ClickEvent.class)); verify(constraintWarningMessage.classList).add(HIDDEN_CSS_CLASS); } |
### Question:
DataTypeConstraintModalView implements DataTypeConstraintModal.View { @Override public void showConstraintWarningMessage() { show(constraintWarningMessage); } @Inject DataTypeConstraintModalView(final HTMLDivElement header,
final HTMLDivElement body,
final HTMLDivElement footer,
final HTMLDivElement componentContainer,
final HTMLButtonElement okButton,
final HTMLButtonElement cancelButton,
final HTMLAnchorElement clearAllAnchor,
final @Named("span") HTMLElement type,
final HTMLDivElement selectConstraint,
final HTMLDivElement constraintWarningMessage,
final HTMLButtonElement closeConstraintWarningMessage); @PostConstruct void init(); @Override void init(final DataTypeConstraintModal presenter); @Override String getHeader(); @Override HTMLElement getBody(); @Override HTMLElement getFooter(); @EventHandler("ok-button") void onOkButtonClick(final ClickEvent e); @EventHandler("cancel-button") void onCancelButtonClick(final ClickEvent e); @EventHandler("clear-all-anchor") void onClearAllAnchorClick(final ClickEvent e); @EventHandler("close-constraint-warning-message") void onCloseConstraintWarningClick(final ClickEvent e); @Override void showConstraintWarningMessage(); @Override void setType(final String type); @Override void setupEmptyContainer(); @Override void loadComponent(final ConstraintType constraintType); @Override void onShow(); @Override void setupOnHideHandler(final Command handler); @Override void enableOkButton(); @Override void disableOkButton(); }### Answer:
@Test public void testShowConstraintWarningMessage() { constraintWarningMessage.classList = mock(DOMTokenList.class); view.showConstraintWarningMessage(); verify(constraintWarningMessage.classList).remove(HIDDEN_CSS_CLASS); } |
### Question:
DataTypeConstraintModalView implements DataTypeConstraintModal.View { @Override public void setupOnHideHandler(final Command handler) { constraintModalJQuery().on("hidden.bs.modal", (e) -> handler.execute()); } @Inject DataTypeConstraintModalView(final HTMLDivElement header,
final HTMLDivElement body,
final HTMLDivElement footer,
final HTMLDivElement componentContainer,
final HTMLButtonElement okButton,
final HTMLButtonElement cancelButton,
final HTMLAnchorElement clearAllAnchor,
final @Named("span") HTMLElement type,
final HTMLDivElement selectConstraint,
final HTMLDivElement constraintWarningMessage,
final HTMLButtonElement closeConstraintWarningMessage); @PostConstruct void init(); @Override void init(final DataTypeConstraintModal presenter); @Override String getHeader(); @Override HTMLElement getBody(); @Override HTMLElement getFooter(); @EventHandler("ok-button") void onOkButtonClick(final ClickEvent e); @EventHandler("cancel-button") void onCancelButtonClick(final ClickEvent e); @EventHandler("clear-all-anchor") void onClearAllAnchorClick(final ClickEvent e); @EventHandler("close-constraint-warning-message") void onCloseConstraintWarningClick(final ClickEvent e); @Override void showConstraintWarningMessage(); @Override void setType(final String type); @Override void setupEmptyContainer(); @Override void loadComponent(final ConstraintType constraintType); @Override void onShow(); @Override void setupOnHideHandler(final Command handler); @Override void enableOkButton(); @Override void disableOkButton(); }### Answer:
@Test public void testSetupOnHideHandler() { final HTMLElement body = mock(HTMLElement.class); final Node modalBody = mock(Node.class); final Node modalContent = mock(Node.class); final Node modalDialog = mock(Node.class); final Node modalComponent = mock(Node.class); final Command command = mock(Command.class); final JQuery jQuery = mock(JQuery.class); final ArgumentCaptor<CallbackFunction> captor = ArgumentCaptor.forClass(CallbackFunction.class); body.parentNode = modalBody; modalBody.parentNode = modalContent; modalContent.parentNode = modalDialog; modalDialog.parentNode = modalComponent; doReturn(body).when(view).getBody(); when(view.constraintModalJQuery()).thenReturn(jQuery); view.setupOnHideHandler(command); verify(jQuery).on(eq("hidden.bs.modal"), captor.capture()); captor.getValue().call(mock(JQueryEvent.class)); verify(command).execute(); } |
### Question:
DataTypeConstraintModal extends Elemental2Modal<DataTypeConstraintModal.View> { @PostConstruct public void setup() { superSetup(); setWidth(WIDTH); this.constraintRange.setModal(this); getView().init(this); } @Inject DataTypeConstraintModal(final View view,
final DataTypeShortcuts dataTypeShortcuts,
final DataTypeConstraintEnumeration constraintEnumeration,
final DataTypeConstraintExpression constraintExpression,
final DataTypeConstraintRange constraintRange); @PostConstruct void setup(); void save(); void show(final BiConsumer<String, ConstraintType> onSaveConsumer); @Override void hide(); void enableOkButton(); void disableOkButton(); }### Answer:
@Test public void testSetup() { doNothing().when(modal).superSetup(); doNothing().when(modal).setWidth(WIDTH); modal.setup(); verify(constraintRange).setModal(modal); verify(modal).superSetup(); verify(modal).setWidth(WIDTH); verify(view).init(modal); } |
### Question:
DataTypeConstraintModal extends Elemental2Modal<DataTypeConstraintModal.View> { public void save() { doSave(getComponentConstraintValue()); } @Inject DataTypeConstraintModal(final View view,
final DataTypeShortcuts dataTypeShortcuts,
final DataTypeConstraintEnumeration constraintEnumeration,
final DataTypeConstraintExpression constraintExpression,
final DataTypeConstraintRange constraintRange); @PostConstruct void setup(); void save(); void show(final BiConsumer<String, ConstraintType> onSaveConsumer); @Override void hide(); void enableOkButton(); void disableOkButton(); }### Answer:
@Test public void testSave() { final DataTypeConstraintComponent constrainComponent = mock(DataTypeConstraintComponent.class); final String value = "value"; doNothing().when(modal).doSave(anyString()); doReturn(constrainComponent).when(modal).getCurrentComponent(); when(constrainComponent.getValue()).thenReturn(value); modal.save(); verify(modal).doSave(value); } |
### Question:
DataTypeConstraintModal extends Elemental2Modal<DataTypeConstraintModal.View> { void clearAll() { constraintType = null; doSave(CONSTRAINT_INITIAL_VALUE); } @Inject DataTypeConstraintModal(final View view,
final DataTypeShortcuts dataTypeShortcuts,
final DataTypeConstraintEnumeration constraintEnumeration,
final DataTypeConstraintExpression constraintExpression,
final DataTypeConstraintRange constraintRange); @PostConstruct void setup(); void save(); void show(final BiConsumer<String, ConstraintType> onSaveConsumer); @Override void hide(); void enableOkButton(); void disableOkButton(); }### Answer:
@Test public void testClearAll() { doNothing().when(modal).doSave(anyString()); modal.clearAll(); verify(modal).doSave(CONSTRAINT_INITIAL_VALUE); } |
### Question:
DataTypeConstraintModal extends Elemental2Modal<DataTypeConstraintModal.View> { void doSave(final String value) { constraintValue = value; getOnSave().accept(value, constraintType); hide(); } @Inject DataTypeConstraintModal(final View view,
final DataTypeShortcuts dataTypeShortcuts,
final DataTypeConstraintEnumeration constraintEnumeration,
final DataTypeConstraintExpression constraintExpression,
final DataTypeConstraintRange constraintRange); @PostConstruct void setup(); void save(); void show(final BiConsumer<String, ConstraintType> onSaveConsumer); @Override void hide(); void enableOkButton(); void disableOkButton(); }### Answer:
@Test public void testDoSave() { final String expectedConstraint = "1,2,3"; final ConstraintType expectedConstraintType = ENUMERATION; final BiConsumer<String, ConstraintType> onSave = mock(BiConsumer.class); doNothing().when(modal).hide(); doReturn(onSave).when(modal).getOnSave(); modal.setConstraintType(expectedConstraintType); modal.doSave(expectedConstraint); final String actualConstraint = modal.getConstraintValue(); assertEquals(expectedConstraint, actualConstraint); verify(onSave).accept(expectedConstraint, expectedConstraintType); verify(modal).hide(); } |
### Question:
DataTypeConstraintModal extends Elemental2Modal<DataTypeConstraintModal.View> { void prepareView() { getView().setType(getConstraintValueType()); if (!isEmpty(getConstraintValue()) || !isNone(getConstraintType())) { getView().loadComponent(getConstraintType()); } else { getView().setupEmptyContainer(); } } @Inject DataTypeConstraintModal(final View view,
final DataTypeShortcuts dataTypeShortcuts,
final DataTypeConstraintEnumeration constraintEnumeration,
final DataTypeConstraintExpression constraintExpression,
final DataTypeConstraintRange constraintRange); @PostConstruct void setup(); void save(); void show(final BiConsumer<String, ConstraintType> onSaveConsumer); @Override void hide(); void enableOkButton(); void disableOkButton(); }### Answer:
@Test public void testPrepareView() { final String type = "string"; final String constraint = "1,2,3"; doReturn(type).when(modal).getConstraintValueType(); doReturn(ENUMERATION).when(modal).getConstraintType(); doReturn(constraint).when(modal).getConstraintValue(); modal.prepareView(); verify(view).setType(type); verify(view).loadComponent(ENUMERATION); } |
### Question:
PointUtils { public static void convertToRelativeBounds(final Node<?, ?> targetNode) { convertBounds(targetNode, (base, delta) -> base - delta); } private PointUtils(); static org.kie.dmn.model.api.dmndi.Point point2dToDMNDIPoint(org.kie.workbench.common.stunner.core.graph.content.view.Point2D point2d); static org.kie.workbench.common.stunner.core.graph.content.view.Point2D dmndiPointToPoint2D(org.kie.dmn.model.api.dmndi.Point dmndiPoint); static void convertToAbsoluteBounds(final Node<?, ?> targetNode); static void convertToRelativeBounds(final Node<?, ?> targetNode); static double xOfShape(final DMNShape shape); static double yOfShape(final DMNShape shape); static double widthOfShape(final DMNShape shape); static double heightOfShape(final DMNShape shape); static Bound upperLeftBound(final View view); static Bound lowerRightBound(final View view); static double xOfBound(final Bound bound); static double yOfBound(final Bound bound); }### Answer:
@Test public void testConvertToRelativeBoundsWhenChild() { final Node<View, Edge> parent = new NodeImpl<>(UUID.uuid()); final View parentView = new ViewImpl<>(new Decision(), Bounds.create(100, 200, 1000, 2000)); parent.setContent(parentView); final Node<View, Edge> child = new NodeImpl<>(UUID.uuid()); final View childView = new ViewImpl<>(new Decision(), Bounds.create(110, 220, 150, 260)); child.setContent(childView); final Edge<Child, Node> edge = new EdgeImpl<>(UUID.uuid()); edge.setContent(new Child()); edge.setSourceNode(parent); edge.setTargetNode(child); parent.getOutEdges().add(edge); child.getInEdges().add(edge); PointUtils.convertToRelativeBounds(child); final Bound ulBound = child.getContent().getBounds().getUpperLeft(); final Bound lrBound = child.getContent().getBounds().getLowerRight(); assertThat(ulBound.getX()).isEqualTo(10); assertThat(ulBound.getY()).isEqualTo(20); assertThat(lrBound.getX()).isEqualTo(50); assertThat(lrBound.getY()).isEqualTo(60); }
@Test public void testConvertToRelativeBoundsWhenNotChild() { final Node<View, ?> node = new NodeImpl<>(UUID.uuid()); final View nodeView = new ViewImpl<>(new Decision(), Bounds.create(10, 20, 50, 60)); node.setContent(nodeView); PointUtils.convertToRelativeBounds(node); final Bound ulBound = node.getContent().getBounds().getUpperLeft(); final Bound lrBound = node.getContent().getBounds().getLowerRight(); assertThat(ulBound.getX()).isEqualTo(10); assertThat(ulBound.getY()).isEqualTo(20); assertThat(lrBound.getX()).isEqualTo(50); assertThat(lrBound.getY()).isEqualTo(60); } |
### Question:
DataTypeConstraintModal extends Elemental2Modal<DataTypeConstraintModal.View> { boolean isNone(final ConstraintType type) { return type == null || Objects.equals(type, NONE); } @Inject DataTypeConstraintModal(final View view,
final DataTypeShortcuts dataTypeShortcuts,
final DataTypeConstraintEnumeration constraintEnumeration,
final DataTypeConstraintExpression constraintExpression,
final DataTypeConstraintRange constraintRange); @PostConstruct void setup(); void save(); void show(final BiConsumer<String, ConstraintType> onSaveConsumer); @Override void hide(); void enableOkButton(); void disableOkButton(); }### Answer:
@Test public void testIsNoneWhenConstraintTypeIsENUMERATION() { assertFalse(modal.isNone(ENUMERATION)); }
@Test public void testIsNoneWhenConstraintTypeIsNONE() { assertTrue(modal.isNone(NONE)); }
@Test public void testIsNoneWhenConstraintTypeIsNull() { assertTrue(modal.isNone(null)); } |
### Question:
DataTypeConstraintModal extends Elemental2Modal<DataTypeConstraintModal.View> { ConstraintType inferComponentType(final String constraintValue) { final String value = Optional.ofNullable(constraintValue).orElse(""); if (isRange(value)) { return RANGE; } else if (isEnumeration(value)) { return ENUMERATION; } else { return EXPRESSION; } } @Inject DataTypeConstraintModal(final View view,
final DataTypeShortcuts dataTypeShortcuts,
final DataTypeConstraintEnumeration constraintEnumeration,
final DataTypeConstraintExpression constraintExpression,
final DataTypeConstraintRange constraintRange); @PostConstruct void setup(); void save(); void show(final BiConsumer<String, ConstraintType> onSaveConsumer); @Override void hide(); void enableOkButton(); void disableOkButton(); }### Answer:
@Test public void testInferComponentTypeWhenItReturnsRange() { final ConstraintType expectedType = RANGE; final ConstraintType actualType = modal.inferComponentType("(1..3]"); assertEquals(expectedType, actualType); }
@Test public void testInferComponentTypeWhenItReturnsEnumeration() { final ConstraintType expectedType = ENUMERATION; final ConstraintType actualType = modal.inferComponentType("1,2,3"); assertEquals(expectedType, actualType); }
@Test public void testInferComponentTypeWhenItReturnsExpression() { final ConstraintType expectedType = EXPRESSION; final ConstraintType actualType = modal.inferComponentType("expression"); assertEquals(expectedType, actualType); } |
### Question:
DataTypeConstraintModal extends Elemental2Modal<DataTypeConstraintModal.View> { public void show(final BiConsumer<String, ConstraintType> onSaveConsumer) { onSave = onSaveConsumer; superShow(); getView().onShow(); getView().setupOnHideHandler(this::onHide); dataTypeShortcuts.disable(); } @Inject DataTypeConstraintModal(final View view,
final DataTypeShortcuts dataTypeShortcuts,
final DataTypeConstraintEnumeration constraintEnumeration,
final DataTypeConstraintExpression constraintExpression,
final DataTypeConstraintRange constraintRange); @PostConstruct void setup(); void save(); void show(final BiConsumer<String, ConstraintType> onSaveConsumer); @Override void hide(); void enableOkButton(); void disableOkButton(); }### Answer:
@Test public void testShow() { final BiConsumer<String, ConstraintType> expectedOnSave = (s, c) -> { }; final ArgumentCaptor<Command> onHide = ArgumentCaptor.forClass(Command.class); doNothing().when(modal).superShow(); modal.show(expectedOnSave); final BiConsumer<String, ConstraintType> actualOnSave = modal.getOnSave(); assertEquals(expectedOnSave, actualOnSave); verify(modal).superShow(); verify(dataTypeShortcuts).disable(); verify(view).onShow(); verify(view).setupOnHideHandler(onHide.capture()); onHide.getValue().execute(); verify(modal).onHide(); } |
### Question:
DataTypeConstraintModal extends Elemental2Modal<DataTypeConstraintModal.View> { @Override public void hide() { superHide(); onHide(); } @Inject DataTypeConstraintModal(final View view,
final DataTypeShortcuts dataTypeShortcuts,
final DataTypeConstraintEnumeration constraintEnumeration,
final DataTypeConstraintExpression constraintExpression,
final DataTypeConstraintRange constraintRange); @PostConstruct void setup(); void save(); void show(final BiConsumer<String, ConstraintType> onSaveConsumer); @Override void hide(); void enableOkButton(); void disableOkButton(); }### Answer:
@Test public void testHide() { doNothing().when(modal).superHide(); modal.hide(); verify(modal).superHide(); verify(dataTypeShortcuts).enable(); } |
### Question:
DataTypeConstraintModal extends Elemental2Modal<DataTypeConstraintModal.View> { void onDataTypeConstraintParserWarningEvent(final @Observes DataTypeConstraintParserWarningEvent e) { getView().showConstraintWarningMessage(); } @Inject DataTypeConstraintModal(final View view,
final DataTypeShortcuts dataTypeShortcuts,
final DataTypeConstraintEnumeration constraintEnumeration,
final DataTypeConstraintExpression constraintExpression,
final DataTypeConstraintRange constraintRange); @PostConstruct void setup(); void save(); void show(final BiConsumer<String, ConstraintType> onSaveConsumer); @Override void hide(); void enableOkButton(); void disableOkButton(); }### Answer:
@Test public void testOnDataTypeConstraintParserWarningEvent() { modal.onDataTypeConstraintParserWarningEvent(mock(DataTypeConstraintParserWarningEvent.class)); verify(view).showConstraintWarningMessage(); } |
### Question:
DataTypeConstraintModal extends Elemental2Modal<DataTypeConstraintModal.View> { public void enableOkButton() { getView().enableOkButton(); } @Inject DataTypeConstraintModal(final View view,
final DataTypeShortcuts dataTypeShortcuts,
final DataTypeConstraintEnumeration constraintEnumeration,
final DataTypeConstraintExpression constraintExpression,
final DataTypeConstraintRange constraintRange); @PostConstruct void setup(); void save(); void show(final BiConsumer<String, ConstraintType> onSaveConsumer); @Override void hide(); void enableOkButton(); void disableOkButton(); }### Answer:
@Test public void testEnableOkButton() { modal.enableOkButton(); verify(view).enableOkButton(); } |
### Question:
DataTypeConstraintModal extends Elemental2Modal<DataTypeConstraintModal.View> { public void disableOkButton() { getView().disableOkButton(); } @Inject DataTypeConstraintModal(final View view,
final DataTypeShortcuts dataTypeShortcuts,
final DataTypeConstraintEnumeration constraintEnumeration,
final DataTypeConstraintExpression constraintExpression,
final DataTypeConstraintRange constraintRange); @PostConstruct void setup(); void save(); void show(final BiConsumer<String, ConstraintType> onSaveConsumer); @Override void hide(); void enableOkButton(); void disableOkButton(); }### Answer:
@Test public void testDisableOkButton() { modal.disableOkButton(); verify(view).disableOkButton(); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.