* Utilities for working with UML. *
* * @author Steffen Herbold */ public class UMLUtils { /** * In case a multiplicity is defined as *, this value defines the highest one that can be picked */ final static int MAX_MULTIPLICITY = 10; /** ** Method for checking if the information in a usage journal can be mapped to the SUT model. In * case this is not possible, the violations are reported. *
* * @param sequences * sequences of the usage journal * @param model * SUT model that is validated * @param testContextName * name of the test context to be used; if null, the first test context found is used * @return number of violations */ public static int validateModelWithLog(Collection* Creates a sequence of events with {@link UMLTransitionType} as event type from a given * sequence of events with the {@link SOAPEventType} or {@link SimpleSOAPEventType}, by matching * the sequences to a state machine. *
* * @param sequence * SOAP sequences * @param stateMachine * the state machine * @return create UML sequences */ public static List* Uses a sequences of events with the {@link UMLTransitionType} to determine the transition * probabilities for the state machine. *
* * @param sequences * UML sequences * @param stateMachine * state machine to be converted to a usage profile */ public static void convertStateMachineToUsageProfile(Collection* Determines all matching {@link Transition} sequences in a state machine for a given sequence * of SOAP events. *
* * @param sequence * SOAP sequence * @param stateMachine * the state machine * @return all matching {@link Transition} sequences */ public static List* Extends a given model with an interaction that represents an observed sequence. *
* * @param sequence * sequence that is added as sequence diagram * @param model * UML model to which the interaction is added * @param interactionName * name of the interaction * @param testContextName * Name of the test context that should be used. If this value is null, the first * test context found is used. */ public static Interaction createInteractionFromEventSequence(List* Calculates the usage score of an interaction as the logsum of the event probabilities * multiplied with the length of the interaction. *
* * @param interaction * interaction for which the score is calculated * @param usageProfile * usage profile used for the calculation * @return calculated usage score */ public static double calculateUsageScore(Interaction interaction, IStochasticProcess usageProfile) { double usageScore = 0.0d; EList* Extends the given model with an activity for usage-based scheduling of the test cases. *
* * @param model * model to be extended * @param usageProfile * usage profile used as foundation */ public static void createScheduling(Model model, IStochasticProcess usageProfile, String testContextName) { final Component testContext = fetchTestContext(model, testContextName); if (testContext == null) { throw new RuntimeException("Could not find any test context in the model"); } Map* Fetches an operation using only its name from a list of operations. Returns the first match * found or null if no match is found. *
* * @param operations * list of operations * @param name * name of the operation * @return first matching operation; null if no match is found */ private static Operation getOperationFromName(EList* Determines which transitions match a given {@link SOAPEventType}. *
* * @param transitions * the transitions * @param eventType * the SOAP event * @return matching transitions */ private static List* Fetches all realized interfaces from the type of a UML {@link Property} (i.e., * property.getType()). If no interfaces are realized, an empty set is returned. *
* * @param property * property, of the whose realized interfaces of the type are determined * @return realized interfaces */ private static Set* Fetches all realized interfaces from a UML {@link Component}. If no interfaces are realized, * an empty set is returned. *
* * @param comp * component whose realized interfaces are determined * @return realized interfaces */ private static Set* Determines searches within a {@link Package} for a component to which the UTP TestContext * stereotype is applied. *
* Retrieves all UML {@link Component}s to which the UTP TestContext stereotype is applied from * a package. This method calls itself recursively to include all components contained in * sub-packages. *
** In case no test context is found, an empty list is returned. *
* * @param pkg * package from which the test contexts are retrieved * @return {@link List} of test contexts */ private static List* Retrieves all properties that represent a UTP TestComponent from a test context. *
* * @param testContext * test context from which the properties are retrieved * @return properties that represent test components */ private static Set* Retrieves all properties that represent a UTP SUT from a test context. *
* * @param testContext * test context from which the properties are retrieved * @return properties that represent the SUTs */ private static Set* Infers connector between two lifelines. *
** TODO: Currently assumes only one connector between two lifelines possible. This assumption is * invalid as soon as there are two ports that connect the same two properties. *
* * @param msgSourceLifeline * source lifeline of the message * @param targetAttributes * target lifeline of the message */ private static Connector inferConnector(Lifeline msgSourceLifeline, Lifeline msgTargetLifeline) { EList* Creates a map that maps the interfaces to the properties, i.e., services that they are * represented by. *
** TODO: currently assumes that each interfaces is only realized by one property *
* * @param model * model for which the interface->service map is created * @return the map */ private static Map* Sets values for the parameters of a call message. The values are, if possible, inferred from * the event that is provided. *
* * @param callMessage * call message for which the parameters are set * @param calledOperation * operation that is called by the message * @param event * event that provides the parameters; in case of null, default values are assumed * @param prefix * prefix of the call message; used to create good warnings and debugging information */ private static void setCallMessageParameters(Message callMessage, Operation calledOperation, Event event, String prefix) { org.w3c.dom.Element requestBody = SOAPUtils.getSoapRequestBodyFromEvent(event); Package instSpecPkg = null; // Set parameters of operation for (Parameter param : calledOperation.getOwnedParameters()) { if (instSpecPkg == null) { instSpecPkg = getOrCreateInstanceSpecificationPackage(param.getModel(), event); } String path = calledOperation.getName() + ":" + param.getName(); Expression argument = (Expression) callMessage.createArgument(param.getName(), param.getType(), UMLPackage.Literals.EXPRESSION); if (isInParameter(param)) { if (param.getType() instanceof DataType) { List* Creates an {@link InstanceSpecification} for a data type in the given package. The values are * inferred, if possible, from the DOM node. The prefix and the path are used for naming the * instance specification and to provide good warnings and debug information in case of * problems. *
* * @param type * DataType for which the {@link InstanceSpecification} is created * @param pkg * package in which the {@link InstanceSpecification} is created * @param prefix * prefix used for naming the {@link InstanceSpecification} * @param currentNode * node of a DOM from which values are inferred * @param path * used for warnings and debug information * @return {@link InstanceSpecification} for the given type */ private static InstanceSpecification createInstanceSpecification(DataType type, Package pkg, String prefix, org.w3c.dom.Element currentNode, String path) { if ("".equals(path)) { path = type.getName(); } InstanceSpecification instSpec = (InstanceSpecification) pkg .createPackagedElement(prefix + "instspec_" + type.getName(), UMLPackage.Literals.INSTANCE_SPECIFICATION); instSpec.getClassifiers().add(type); for (Property prop : type.getAllAttributes()) { if (prop.getType() instanceof PrimitiveType) { createSlotPrimitiveType(instSpec, prop, currentNode, path); } else if (prop.getType() instanceof DataType) { List* Gets or creates a {@link Package} for {@link InstanceSpecification} created by the * usage-based testing. Each service gets its own sub-package within a package called * UBT_InstanceSpecifications. " *
* * @param model * model in which the package is generated * @param event * event from which the service name is inferred * @return package for the {@link InstanceSpecification}s */ private static Package getOrCreateInstanceSpecificationPackage(Model model, Event event) { String pkgUBTInstSpecs = "UBT_InstanceSpecifications"; Package ubtInstSpecPkg = (Package) model.getOwnedMember(pkgUBTInstSpecs); if (ubtInstSpecPkg == null) { ubtInstSpecPkg = (Package) model.createPackagedElement(pkgUBTInstSpecs, UMLPackage.Literals.PACKAGE); } String serviceName = SOAPUtils.getServiceNameFromEvent(event); Package serviceInstSpecPkg = (Package) ubtInstSpecPkg.getOwnedMember(serviceName); if (serviceInstSpecPkg == null) { serviceInstSpecPkg = (Package) ubtInstSpecPkg.createPackagedElement(serviceName, UMLPackage.Literals.PACKAGE); } return serviceInstSpecPkg; } /** ** Creates an operand that defines a {@link PrimitiveType}. *
** TODO: Currently does nothing in case of multiplicity 0. I am not sure if, in that case, one * has to define LiteralNull instead. *
* * @param param * parameter for which the operand is created * @param argument * argument to which the operand is added * @param currentNode * DOM node from which is value for the operand is inferred * @param path * used for warnings and debug information */ private static void createOperandPrimitiveType(Parameter param, Expression argument, org.w3c.dom.Element currentNode, String path) { List* Creates a {@link Slot} in an {@link InstanceSpecification} for a primitive type. *
* * @param instSpec * instance specification to which the slot is added * @param prop * property that describes the slot * @param currentNode * DOM node from which is value for the slot is inferred * @param path * used for warnings and debug information */ private static void createSlotPrimitiveType(InstanceSpecification instSpec, Property prop, org.w3c.dom.Element currentNode, String path) { List* Sets values for the parameters of a reply message. The values are, all LiterealNull and to * the INOUT, OUT and REPLY parameters, the UTP stereotype LiteralAny is applied. *
* * @param replyMessage * reply message for which the parameters are set * @param calledOperation * operation that is replied for by the message */ private static void setReplyMessageParameters(Message replyMessage, Operation calledOperation) { for (Parameter param : calledOperation.getOwnedParameters()) { Expression argument = (Expression) replyMessage.createArgument(param.getName(), param.getType(), UMLPackage.Literals.EXPRESSION); ValueSpecification operand = argument.createOperand(null, param.getType(), UMLPackage.Literals.LITERAL_NULL); if (isOutParameter(param)) { operand.applyStereotype(UTPUtils.getLiteralAnyStereotype(param.getModel())); } } } /** ** Checks if a parameter has the direction IN or INOUT *
* * @param parameter * parameter that is checked * @return true if the direction is IN or INOUT; false otherwise */ private static boolean isInParameter(Parameter parameter) { return parameter.getDirection() == ParameterDirectionKind.IN_LITERAL || parameter.getDirection() == ParameterDirectionKind.INOUT_LITERAL; } /** ** Checks if a parameter has the direction RETURN, OUT or INOUT *
* * @param parameter * parameter that is checked * @return true if the direction is RETURN, OUT, or INOUT; false otherwise */ private static boolean isOutParameter(Parameter parameter) { return parameter.getDirection() == ParameterDirectionKind.RETURN_LITERAL || parameter.getDirection() == ParameterDirectionKind.OUT_LITERAL || parameter.getDirection() == ParameterDirectionKind.INOUT_LITERAL; } /** ** Checks if the {@link MessageSort} of a message is a call message, i.e., ASYNCH_CALL or * SYNCH_CALL. *
* * @param message * message that is checked * @return true if the message is a call message; false otherwise */ private static boolean isCallMessage(Message message) { if (message == null) { return false; } MessageSort msgSort = message.getMessageSort(); return msgSort == MessageSort.ASYNCH_CALL_LITERAL || msgSort == MessageSort.SYNCH_CALL_LITERAL; } /** ** inverse-sorts the values of a map. Has been adapted from this StackOverflow post. *
* * @param map * map whose values are sorted * @return sorted version of the map */ private static