Changeset 1926 for trunk/autoquest-plugin-uml

Timestamp:

03/18/15 10:05:36 (10 years ago)

Author:

sherbold

Message:

• UMLUtils now add real values to test cases based on the observations in the event sequence
• test updated

File:

• trunk/autoquest-plugin-uml/src/main/java/de/ugoe/cs/autoquest/plugin/uml/UMLUtils.java (modified) (21 diffs)

trunk/autoquest-plugin-uml/src/main/java/de/ugoe/cs/autoquest/plugin/uml/UMLUtils.java

@@ -15 +15 @@
 package de.ugoe.cs.autoquest.plugin.uml;
 
+import java.io.StringWriter;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -30 +32 @@
 import java.util.TreeSet;
 
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
 import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.URI;
 import org.eclipse.uml2.uml.Activity;
 import org.eclipse.uml2.uml.ActivityEdge;
 import org.eclipse.uml2.uml.ActivityNode;
 import org.eclipse.uml2.uml.CallConcurrencyKind;
+import org.eclipse.uml2.uml.CallEvent;
 import org.eclipse.uml2.uml.CallOperationAction;
 import org.eclipse.uml2.uml.Comment;
@@ -66 +77 @@
 import org.eclipse.uml2.uml.Property;
 import org.eclipse.uml2.uml.Region;
+import org.eclipse.uml2.uml.Relationship;
 import org.eclipse.uml2.uml.Slot;
 import org.eclipse.uml2.uml.StateMachine;
 import org.eclipse.uml2.uml.Stereotype;
 import org.eclipse.uml2.uml.Transition;
+import org.eclipse.uml2.uml.Trigger;
+import org.eclipse.uml2.uml.Type;
 import org.eclipse.uml2.uml.UMLPackage;
 import org.eclipse.uml2.uml.Vertex;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
 
 import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.plugin.http.SOAPUtils;
 import de.ugoe.cs.autoquest.plugin.http.eventcore.SOAPEventType;
 import de.ugoe.cs.autoquest.plugin.http.eventcore.SimpleSOAPEventType;
 import de.ugoe.cs.autoquest.plugin.uml.eventcore.UMLTransitionType;
 import de.ugoe.cs.autoquest.usageprofiles.IStochasticProcess;
+import de.ugoe.cs.util.StringTools;
 import de.ugoe.cs.util.console.Console;
 
@@ -88 +107 @@
  */
 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;
+
+    final public static URI UML_PRIMITIVE_TYPES_URI = URI
+        .createURI("pathmap://UML_LIBRARIES/UMLPrimitiveTypes.library.uml", true);
 
     /**
@@ -135 +162 @@
         for (List<Event> sequence : sequences) {
             for (Event event : sequence) {
-                String serviceName = getServiceNameFromEvent(event);
-                String calledMethod = getCalledMethodFromEvent(event);
-                if( serviceName!=null ) {
+                String serviceName = SOAPUtils.getServiceNameFromEvent(event);
+                String calledMethod = SOAPUtils.getCalledMethodFromEvent(event);
+                if (serviceName != null) {
                     Set<String> curCalledMethods = calledMethods.get(serviceName);
                     if (curCalledMethods == null) {
@@ -152 +179 @@
         for (Entry<String, Set<String>> entry : calledMethods.entrySet()) {
             Console.traceln(Level.INFO, "\tService \"" + entry.getKey() + "\": ");
-            for(String method : entry.getValue()) {
-                Console.traceln(Level.INFO, "\t\t"+method);
+            for (String method : entry.getValue()) {
+                Console.traceln(Level.INFO, "\t\t" + method);
             }
         }
@@ -204 +231 @@
                                     "\tFound the following realized interfaces for the service \"" +
                                         serviceName + "\": ");
-                    for( Interface intface : interfaces ) {
+                    for (Interface intface : interfaces) {
                         Console.traceln(Level.INFO, "\t" + intface.getName());
-                        for( Operation operation : intface.getAllOperations() ) {
+                        for (Operation operation : intface.getAllOperations()) {
                             Console.traceln(Level.INFO, "\t\t" + operation.getName());
                         }
@@ -235 +262 @@
      * <p>
      * Creates a sequence of events with {@link UMLTransitionType} as event type from a given
-     * sequence of events with the {@link SOAPEventType}, by matching the sequences to a state
-     * machine.
+     * sequence of events with the {@link SOAPEventType} or {@link SimpleSOAPEventType}, by matching
+     * the sequences to a state machine.
      * </p>
      * 
@@ -248 +275 @@
                                                           StateMachine stateMachine)
     {
+        System.out.println("foo");
         List<List<Transition>> matchingSequences =
             determineMatchingTransitionSequences(sequence, stateMachine);
+        System.out.println(matchingSequences.size());
 
         if (matchingSequences.size() != 1) {
@@ -370 +399 @@
         for (Iterator<Event> eventIterator = sequence.iterator(); eventIterator.hasNext();) {
             Event event = eventIterator.next();
-            if (event.getType() instanceof SOAPEventType) {
-                SOAPEventType eventType = (SOAPEventType) event.getType();
-                if (matchingSequences == null) {
-                    matchingSequences = new LinkedList<>();
-                    List<Transition> initialMatches = matchTransitions(allTransitions, eventType);
-                    for (Transition transition : initialMatches) {
-                        List<Transition> candidate = new LinkedList<>();
-                        candidate.add(transition);
-                        matchingSequences.add(candidate);
-                    }
-                    currentTransitions = initialMatches;
-                }
-                else {
-                    List<List<Transition>> nextMatchingSequences = new LinkedList<>();
-                    List<Transition> nextCurrentTransitions = new LinkedList<>();
-                    Iterator<Transition> currentTransitionIterator = currentTransitions.iterator();
-                    Iterator<List<Transition>> currentMatchingSequencesIterator =
-                        matchingSequences.iterator();
-                    while (currentTransitionIterator.hasNext()) {
-                        Transition currentTransition = currentTransitionIterator.next();
-                        List<Transition> currentMatch = currentMatchingSequencesIterator.next();
-
-                        List<Transition> matches =
-                            matchTransitions(currentTransition.getTarget().getOutgoings(),
-                                             eventType);
-                        if (matches.isEmpty()) {
-                            throw new RuntimeException("no matches found");
-                        }
-                        for (Transition matchingTransition : matches) {
-                            List<Transition> candidate = new LinkedList<>(currentMatch);
-                            candidate.add(matchingTransition);
-                            nextMatchingSequences.add(candidate);
-                            nextCurrentTransitions.add(matchingTransition);
-                        }
-                    }
-                    matchingSequences = nextMatchingSequences;
-                    currentTransitions = nextCurrentTransitions;
-                }
+            System.out.println(event);
+            System.out.println(matchingSequences);
+            if (matchingSequences == null) {
+                matchingSequences = new LinkedList<>();
+                List<Transition> initialMatches = matchTransitions(allTransitions, event);
+                for (Transition transition : initialMatches) {
+                    List<Transition> candidate = new LinkedList<>();
+                    candidate.add(transition);
+                    matchingSequences.add(candidate);
+                }
+                currentTransitions = initialMatches;
             }
             else {
-                throw new RuntimeException(
-                                           "Wrong event type. Only UMLTransitionType supported but was: " +
-                                               event.getType().getClass().getName());
+                List<List<Transition>> nextMatchingSequences = new LinkedList<>();
+                List<Transition> nextCurrentTransitions = new LinkedList<>();
+                Iterator<Transition> currentTransitionIterator = currentTransitions.iterator();
+                Iterator<List<Transition>> currentMatchingSequencesIterator =
+                    matchingSequences.iterator();
+                while (currentTransitionIterator.hasNext()) {
+                    Transition currentTransition = currentTransitionIterator.next();
+                    List<Transition> currentMatch = currentMatchingSequencesIterator.next();
+
+                    List<Transition> matches =
+                        matchTransitions(currentTransition.getTarget().getOutgoings(), event);
+                    if (matches.isEmpty()) {
+                        throw new RuntimeException("no matches found");
+                    }
+                    for (Transition matchingTransition : matches) {
+                        List<Transition> candidate = new LinkedList<>(currentMatch);
+                        candidate.add(matchingTransition);
+                        nextMatchingSequences.add(candidate);
+                        nextCurrentTransitions.add(matchingTransition);
+                    }
+                }
+                matchingSequences = nextMatchingSequences;
+                currentTransitions = nextCurrentTransitions;
             }
         }
@@ -444 +466 @@
         final Stereotype utpTestContext = (Stereotype) utpProfile.getOwnedMember("TestContext");
 
+        // add UML Primitive types
+        // final UMLResource umlRes = (UMLResource)
+        // model.eResource().getResourceSet().getResource(UML_PRIMITIVE_TYPES_URI, true);
+        // model = (Model) umlRes.getContents().get(0);
+
         Component testContext = fetchTestContext(model, utpTestContext, testContextName);
         if (testContext == null) {
@@ -485 +512 @@
         for (Event event : sequence) {
             if (!(event.equals(Event.STARTEVENT) || event.equals(Event.ENDEVENT))) {
-                String serviceName = getServiceNameFromEvent(event);
-                String methodName = getCalledMethodFromEvent(event);
-                String clientName = getClientNameFromEvent(event);
+                String serviceName = SOAPUtils.getServiceNameFromEvent(event);
+                String methodName = SOAPUtils.getCalledMethodFromEvent(event);
+                String clientName = SOAPUtils.getClientNameFromEvent(event);
+                String prefix = interactionName + ":" + i + ":" + methodName + "_";
                 // determine lifelines
                 Lifeline msgTargetLifeline;
                 Lifeline msgSourceLifeline;
-                
+
                 msgSourceLifeline = interaction.getLifeline(clientName);
                 msgTargetLifeline = interaction.getLifeline(serviceName);
-                
+
                 if (msgSourceLifeline == null) {
                     throw new RuntimeException(
-                                               "Error creating message: could not determine source lifeline for component: " + clientName);
+                                               "Error creating message: could not determine source lifeline for component: " +
+                                                   clientName);
                 }
                 if (msgTargetLifeline == null) {
                     throw new RuntimeException(
-                                               "Error creating message: could not determine target lifeline for component: " + serviceName);
+                                               "Error creating message: could not determine target lifeline for component: " +
+                                                   serviceName);
                 }
                 // determine correct target interface
@@ -541 +571 @@
                 // setup for both SYNCH and ASYNCH calls
                 MessageOccurrenceSpecification callSendFragment =
-                    (MessageOccurrenceSpecification) interaction
-                        .createFragment(i + ":" + methodName + "_callSendFragment",
-                                        UMLPackage.Literals.MESSAGE_OCCURRENCE_SPECIFICATION);
+                    (MessageOccurrenceSpecification) interaction.createFragment(prefix +
+                        "callSendFragment", UMLPackage.Literals.MESSAGE_OCCURRENCE_SPECIFICATION);
                 MessageOccurrenceSpecification callRecvFragment =
-                    (MessageOccurrenceSpecification) interaction
-                        .createFragment(i + ":" + methodName + "_callRecvFragment",
-                                        UMLPackage.Literals.MESSAGE_OCCURRENCE_SPECIFICATION);
+                    (MessageOccurrenceSpecification) interaction.createFragment(prefix +
+                        "callRecvFragment", UMLPackage.Literals.MESSAGE_OCCURRENCE_SPECIFICATION);
 
                 callSendFragment.setCovered(msgSourceLifeline);
@@ -554 +582 @@
                 // create call
                 Message callMessage = interaction.createMessage(methodName);
-                callMessage.setSignature(calledOperation); 
-                setMessageParameters(callMessage, calledOperation, event);
+                callMessage.setSignature(calledOperation);
+                setMessageParameters(callMessage, calledOperation, event, prefix);
                 callMessage.setConnector(inferConnector(msgSourceLifeline, msgTargetLifeline));
                 callMessage.setSendEvent(callSendFragment);
@@ -577 +605 @@
                     MessageOccurrenceSpecification replySendFragment =
                         (MessageOccurrenceSpecification) interaction
-                            .createFragment(i + ":" + methodName + "_replySendFragment",
+                            .createFragment(prefix + "replySendFragment",
                                             UMLPackage.Literals.MESSAGE_OCCURRENCE_SPECIFICATION);
                     MessageOccurrenceSpecification replyRecvFragment =
                         (MessageOccurrenceSpecification) interaction
-                            .createFragment(i + ":" + methodName + "_replyRecvFragment",
+                            .createFragment(prefix + "replyRecvFragment",
                                             UMLPackage.Literals.MESSAGE_OCCURRENCE_SPECIFICATION);
 
@@ -618 +646 @@
     }
 
-    
-
     /**
      * <p>
@@ -653 +679 @@
                             .getName();
                 }
-                eventSequence.add(new Event(new SimpleSOAPEventType(methodName, serviceName,""))); // TODO add client name
+                // eventSequence.add(new Event(new SimpleSOAPEventType(methodName, serviceName, "",
+                // ))); // TODO
+                // add
+                // client
+                // name
             }
         }
@@ -755 +785 @@
         }
         return result;
-    }
-
-    /**
-     * <p>
-     * Helper function to get the name of a service from a SOAP event.
-     * </p>
-     * 
-     * @param event
-     *            event for which the service name is retrieved
-     * @return service name
-     */
-    protected static String getServiceNameFromEvent(Event event) {
-        if (event.getType() instanceof SOAPEventType) {
-            return ((SOAPEventType) event.getType()).getServiceName();
-        }
-        else if (event.getType() instanceof SimpleSOAPEventType) {
-            return ((SimpleSOAPEventType) event.getType()).getServiceName();
-        }
-        else {
-            throw new RuntimeException(
-                                       "Wrong event type. Only SOAPEventType and SimpleSOAPEventType supported but was: " +
-                                           event.getType().getClass().getName());
-        }
-    }
-
-    /**
-     * 
-     * <p>
-     * Helper function to get the called method from a SOAP event
-     * </p>
-     * 
-     * @param event
-     *            event for which the called method is retrieved
-     * @return called method
-     */
-    private static String getCalledMethodFromEvent(Event event) {
-        if (event.getType() instanceof SOAPEventType) {
-            return ((SOAPEventType) event.getType()).getCalledMethod();
-        }
-        else if (event.getType() instanceof SimpleSOAPEventType) {
-            return ((SimpleSOAPEventType) event.getType()).getCalledMethod();
-        }
-        else {
-            throw new RuntimeException(
-                                       "Wrong event type. Only SOAPEventType and SimpleSOAPEventType supported but was: " +
-                                           event.getType().getClass().getName());
-        }
-    }
-    
-    /**
-     * <p>
-     * Helper function to get the name of a client from a SOAP event.
-     * </p>
-     * 
-     * @param event
-     *            event for which the client name is retrieved
-     * @return service name
-     */
-    protected static String getClientNameFromEvent(Event event) {
-        if (event.getType() instanceof SOAPEventType) {
-            return ((SOAPEventType) event.getType()).getClientName();
-        }
-        else if (event.getType() instanceof SimpleSOAPEventType) {
-            return ((SimpleSOAPEventType) event.getType()).getClientName();
-        }
-        else {
-            throw new RuntimeException(
-                                       "Wrong event type. Only SOAPEventType and SimpleSOAPEventType supported but was: " +
-                                           event.getType().getClass().getName());
-        }
     }
 
@@ -864 +824 @@
      * @return matching transitions
      */
-    private static List<Transition> matchTransitions(List<Transition> transitions,
-                                                     SOAPEventType eventType)
-    {
+    private static List<Transition> matchTransitions(List<Transition> transitions, Event event) {
+        String eventService = SOAPUtils.getServiceNameFromEvent(event);
+        String eventMethod = SOAPUtils.getCalledMethodFromEvent(event);
+
+        Map<Interface, String> interfaceServiceMap =
+            createInterfaceServiceMap(transitions.get(0).getModel());
+
         List<Transition> matching = new LinkedList<>();
         for (Transition transition : transitions) {
-            // String serviceName = transition.getName().split("\\.")[0]; // TODO service name check
-            String methodName = transition.getName().split("\\.")[1];
-            if (methodName.equals(eventType.getCalledMethod())) {
-                matching.add(transition);
-            }
+            EList<Trigger> triggers = transition.getTriggers();
+            if (triggers.size() == 1) {
+                if (triggers.get(0).getEvent() instanceof CallEvent) {
+                    CallEvent callEvent = (CallEvent) triggers.get(0).getEvent();
+                    String transitionMethod = callEvent.getOperation().getName();
+
+                    Interface intface = callEvent.getOperation().getInterface();
+                    for (Relationship relationship : intface.getRelationships()) {
+                        for (Element element : relationship.getRelatedElements()) {
+                            if (element instanceof Component) {
+
+                            }
+                        }
+                    }
+
+                    String transitionService =
+                        interfaceServiceMap.get(callEvent.getOperation().getInterface());
+                    if (eventMethod.equals(transitionMethod) &&
+                        eventService.equals(transitionService))
+                    {
+                        matching.add(transition);
+                    }
+                }
+            }
+
         }
         return matching;
@@ -970 +954 @@
         return null;
     }
-    
-    private static void setMessageParameters(Message callMessage, Operation calledOperation, Event event) {
+
+    private static Map<Interface, String> createInterfaceServiceMap(Model model) {
+        Map<Interface, String> interfaceServiceMap = new HashMap<>();
+        final Profile utpProfile = model.getModel().getAppliedProfile("utp");
+        final Stereotype utpTestComponent = (Stereotype) utpProfile.getOwnedMember("TestComponent");
+        final Stereotype utpSUT = (Stereotype) utpProfile.getOwnedMember("SUT");
+        final Stereotype utpTestContext = (Stereotype) utpProfile.getOwnedMember("TestContext");
+        List<Component> testContexts =
+            fetchTestContextRecursively(model.getModel(), utpTestContext);
+        for (Component testContext : testContexts) {
+            for (Property property : testContext.getAllAttributes()) {
+                if (property.getAppliedStereotypes().contains(utpSUT) ||
+                    property.getType().getAppliedStereotypes().contains(utpTestComponent))
+                {
+                    for (Interface intface : getRealizedInterfacesFromProperty(property)) {
+                        interfaceServiceMap.put(intface, property.getName());
+                    }
+                }
+            }
+        }
+        return interfaceServiceMap;
+    }
+
+    private static void setMessageParameters(Message callMessage,
+                                             Operation calledOperation,
+                                             Event event,
+                                             String prefix)
+    {
+        org.w3c.dom.Element requestBody = SOAPUtils.getSoapRequestBodyFromEvent(event);
+
         // Set parameters of operation
-        for( Parameter param : calledOperation.getOwnedParameters() ) {
-            Expression argument = (Expression) callMessage.createArgument(param.getName(), param.getType(), UMLPackage.Literals.EXPRESSION);
-            
-            if( param.getDirection()==ParameterDirectionKind.IN_LITERAL || param.getDirection()==ParameterDirectionKind.INOUT_LITERAL) {
-                if( param.getType() instanceof DataType ) {
-                    InstanceSpecification instSpec = createInstanceSpecification((DataType) param.getType(), event);
-                    
-                    InstanceValue value = (InstanceValue) argument.createOperand(null, param.getType(), UMLPackage.Literals.INSTANCE_VALUE);
-                    value.setInstance(instSpec);
-                }
-                else if( param.getType() instanceof PrimitiveType ) {
-                    if( "String".equals(param.getType().getName()) ) {
-                        LiteralString spec = (LiteralString) argument.createOperand(param.getName(), null, UMLPackage.Literals.LITERAL_STRING);
-                        spec.setValue("foobar"); // TODO needs to be real value
-                    }
-                    else if( "Integer".equals(param.getType().getName()) ) {
-                        LiteralInteger spec = (LiteralInteger) argument.createOperand(param.getName(), null, UMLPackage.Literals.LITERAL_INTEGER);
-                        spec.setValue(42); // TODO needs to be real value
-                    }
-                    else if( "Boolean".equals(param.getType().getName()) ) {
-                        LiteralBoolean spec = (LiteralBoolean) argument.createOperand(param.getName(), null, UMLPackage.Literals.LITERAL_BOOLEAN);
-                        spec.setValue(true); // TODO needs to be real value
-                    }
-                    else if( "Real".equals(param.getType().getName()) ) {
-                        LiteralReal spec = (LiteralReal) argument.createOperand(param.getName(), null, UMLPackage.Literals.LITERAL_REAL);
-                        spec.setValue(3.14); // TODO needs to be real value
-                    }
-                }
-            } else {
+        for (Parameter param : calledOperation.getOwnedParameters()) {
+            Expression argument =
+                (Expression) callMessage.createArgument(param.getName(), param.getType(),
+                                                        UMLPackage.Literals.EXPRESSION);
+
+            if (param.getDirection() == ParameterDirectionKind.IN_LITERAL ||
+                param.getDirection() == ParameterDirectionKind.INOUT_LITERAL)
+            {
+                if (param.getType() instanceof DataType) {
+                    List<org.w3c.dom.Element> paramNodes =
+                        getMatchingChildNode((DataType) param.getType(), requestBody);
+                    for (org.w3c.dom.Element paramNode : paramNodes) {
+                        InstanceSpecification instSpec =
+                            createInstanceSpecification((DataType) param.getType(), event, prefix,
+                                                        paramNode, "");
+
+                        InstanceValue value =
+                            (InstanceValue) argument
+                                .createOperand(null, param.getType(),
+                                               UMLPackage.Literals.INSTANCE_VALUE);
+                        value.setInstance(instSpec);
+                    }
+                }
+                else if (param.getType() instanceof PrimitiveType) {
+                    createOperandPrimitiveType(param, argument, requestBody);
+                }
+            }
+            else {
                 // set literalNull for out and return parameters
                 argument.createOperand(null, param.getType(), UMLPackage.Literals.LITERAL_NULL);
@@ -1007 +1018 @@
         }
     }
-    
-    public static InstanceSpecification createInstanceSpecification(DataType type, Event event) {
+
+    private static InstanceSpecification createInstanceSpecification(DataType type,
+                                                                     Event event,
+                                                                     String prefix,
+                                                                     org.w3c.dom.Element currentNode,
+                                                                     String path)
+    {
+        if ("".equals(path)) {
+            path = type.getName();
+        }
+        // System.out.println(path);
         String pkgUBTInstSpecs = "UBT_InstanceSpecifications";
         Model model = type.getModel();
         Package ubtInstSpecPkg = (Package) model.getOwnedMember(pkgUBTInstSpecs);
-        if( ubtInstSpecPkg==null ) {
-            ubtInstSpecPkg = (Package) type.getModel().createPackagedElement(pkgUBTInstSpecs, UMLPackage.Literals.PACKAGE);
-        }
-        String serviceName = getServiceNameFromEvent(event);
+        if (ubtInstSpecPkg == null) {
+            ubtInstSpecPkg =
+                (Package) type.getModel().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);
-        }
-        
-        InstanceSpecification instSpec = (InstanceSpecification) serviceInstSpecPkg.createPackagedElement("instspec_"+type.getName(), UMLPackage.Literals.INSTANCE_SPECIFICATION);
+        if (serviceInstSpecPkg == null) {
+            serviceInstSpecPkg =
+                (Package) ubtInstSpecPkg.createPackagedElement(serviceName,
+                                                               UMLPackage.Literals.PACKAGE);
+        }
+
+        InstanceSpecification instSpec =
+            (InstanceSpecification) serviceInstSpecPkg.createPackagedElement(prefix + "instspec_" +
+                type.getName(), UMLPackage.Literals.INSTANCE_SPECIFICATION);
         instSpec.getClassifiers().add(type);
-        for( Property prop : type.getAllAttributes() ) {
-            // TODO handle multiplicity
-            //int lowerBound = prop.getLower();
-            //int upperBound = prop.getUpper();
-            
+        for (Property prop : type.getAllAttributes()) {
+            if (prop.getType() instanceof PrimitiveType) {
+                createSlotPrimitiveType(instSpec, prop, currentNode, path);
+            }
+            else if (prop.getType() instanceof DataType) {
+                List<org.w3c.dom.Element> attributeNodes = null;
+                int multiplicityChosen = 0;
+                if (currentNode != null) {
+                    attributeNodes = getMatchingChildNode(prop, currentNode);
+                    multiplicityChosen = attributeNodes.size();
+                }
+
+                if (multiplicityChosen == 0 && prop.getLower() > 0) {
+                    if (currentNode != null) {
+                        Console.traceln(Level.WARNING,
+                                        "required attribute not found in SOAP message: " + path +
+                                            "." + prop.getName());
+                        Console
+                            .traceln(Level.WARNING,
+                                     "setting default values for this attribute and all its children");
+                        Console.traceln(Level.FINE, "XML structure of path:" + StringTools.ENDLINE +
+                            SOAPUtils.getSerialization(currentNode));
+                    }
+                    multiplicityChosen = prop.getLower();
+                }
+                for (int i = 0; i < multiplicityChosen; i++) {
+                    org.w3c.dom.Element attributeNode = null;
+                    if (attributeNodes != null && !attributeNodes.isEmpty()) {
+                        attributeNode = attributeNodes.get(i);
+                    }
+
+                    Slot slot = instSpec.createSlot();
+                    slot.setDefiningFeature(prop);
+
+                    InstanceValue value =
+                        (InstanceValue) slot.createValue(prop.getName() + "_" + i, prop.getType(),
+                                                         UMLPackage.Literals.INSTANCE_VALUE);
+                    value.setInstance(createInstanceSpecification((DataType) prop.getType(), event,
+                                                                  prefix, attributeNode, path +
+                                                                      "." + prop.getName()));
+                }
+            }
+            else {
+                Console.traceln(Level.SEVERE, "property neither DataType nor PrimitiveType: " +
+                    prop.getType());
+                // TODO abort?
+            }
+        }
+        return instSpec;
+    }
+
+    private static void createOperandPrimitiveType(Parameter param,
+                                                   Expression argument,
+                                                   org.w3c.dom.Element currentNode)
+    {
+        if ("String".equals(param.getType().getName())) {
+            LiteralString spec =
+                (LiteralString) argument.createOperand(param.getName(), null,
+                                                       UMLPackage.Literals.LITERAL_STRING);
+            spec.setValue("foobar"); // TODO needs to be real value
+        }
+        else if ("Integer".equals(param.getType().getName())) {
+            LiteralInteger spec =
+                (LiteralInteger) argument.createOperand(param.getName(), null,
+                                                        UMLPackage.Literals.LITERAL_INTEGER);
+            spec.setValue(42); // TODO needs to be real value
+        }
+        else if ("Boolean".equals(param.getType().getName())) {
+            LiteralBoolean spec =
+                (LiteralBoolean) argument.createOperand(param.getName(), null,
+                                                        UMLPackage.Literals.LITERAL_BOOLEAN);
+            spec.setValue(true); // TODO needs to be real value
+        }
+        else if ("Real".equals(param.getType().getName())) {
+            LiteralReal spec =
+                (LiteralReal) argument.createOperand(param.getName(), null,
+                                                     UMLPackage.Literals.LITERAL_REAL);
+            spec.setValue(3.14); // TODO needs to be real value
+        }
+    }
+
+    private static void createSlotPrimitiveType(InstanceSpecification instSpec,
+                                                Property prop,
+                                                org.w3c.dom.Element currentNode,
+                                                String path)
+    {
+        List<String> attributeValues = getPrimitiveTypeValuesFromElement(prop, currentNode);
+
+        if (attributeValues.isEmpty()) {
+            if (prop.getLower() == 0) {
+                // ignoring optional attribute
+                return;
+            }
+            else {
+                if (currentNode != null) {
+                    Console.traceln(Level.WARNING,
+                                    "required attribute not found in SOAP message: " + path + "." +
+                                        prop.getName());
+                    Console.traceln(Level.WARNING, "setting default values for this attribute");
+                }
+                Console.traceln(Level.FINE, "XML structure of path:" + StringTools.ENDLINE +
+                    SOAPUtils.getSerialization(currentNode));
+                attributeValues.add(null);
+            }
+        }
+        for (String attributeValue : attributeValues) {
             Slot slot = instSpec.createSlot();
             slot.setDefiningFeature(prop);
-            if( prop.getType() instanceof PrimitiveType ) {
-                if( "String".equals(prop.getType().getName()) ) {
-                    LiteralString value = (LiteralString) slot.createValue(prop.getName(), null, UMLPackage.Literals.LITERAL_STRING);
-                    value.setValue("foobar"); // TODO needs to be real value
-                }
-                else if( "Integer".equals(prop.getType().getName()) ) {
-                    LiteralInteger value = (LiteralInteger) slot.createValue(prop.getName(), null, UMLPackage.Literals.LITERAL_INTEGER);
-                    value.setValue(42); // TODO needs to be real value
-                }
-                else if( "Boolean".equals(prop.getType().getName()) ) {
-                    LiteralBoolean value = (LiteralBoolean) slot.createValue(prop.getName(), null, UMLPackage.Literals.LITERAL_BOOLEAN);
-                    value.setValue(true); // TODO needs to be real value
-                }
-                else if( "Real".equals(prop.getType().getName()) ) {
-                    LiteralReal value = (LiteralReal) slot.createValue(prop.getName(), null, UMLPackage.Literals.LITERAL_REAL);
+            if ("String".equals(prop.getType().getName())) {
+                LiteralString value =
+                    (LiteralString) slot.createValue(prop.getName(), null,
+                                                     UMLPackage.Literals.LITERAL_STRING);
+                if (attributeValue != null) {
+                    value.setValue(attributeValue);
+                }
+                else {
+                    value.setValue("foobar");
+                }
+            }
+            else if ("Integer".equals(prop.getType().getName())) {
+                LiteralInteger value =
+                    (LiteralInteger) slot.createValue(prop.getName(), null,
+                                                      UMLPackage.Literals.LITERAL_INTEGER);
+                if (attributeValue != null) {
+                    value.setValue(Integer.parseInt(attributeValue));
+                }
+                else {
+                    value.setValue(42);
+                }
+            }
+            else if ("Boolean".equals(prop.getType().getName())) {
+                LiteralBoolean value =
+                    (LiteralBoolean) slot.createValue(prop.getName(), null,
+                                                      UMLPackage.Literals.LITERAL_BOOLEAN);
+                if (attributeValue != null) {
+                    value.setValue(Boolean.parseBoolean(attributeValue));
+                }
+                else {
+                    value.setValue(true);
+                }
+            }
+            else if ("Real".equals(prop.getType().getName())) {
+                LiteralReal value =
+                    (LiteralReal) slot.createValue(prop.getName(), null,
+                                                   UMLPackage.Literals.LITERAL_REAL);
+                if (attributeValue != null) {
+                    value.setValue(Double.parseDouble(attributeValue));
+                }
+                else {
                     value.setValue(3.14); // TODO needs to be real value
                 }
             }
-            else if( prop.getType() instanceof DataType ) {
-                InstanceValue value = (InstanceValue) slot.createValue(prop.getName(), prop.getType(), UMLPackage.Literals.INSTANCE_VALUE);
-                value.setInstance(createInstanceSpecification((DataType) prop.getType(), event));
-            }
-        }
-        return instSpec;
-    }
+            else {
+                Console.traceln(Level.SEVERE, "could not create literal for primitive type: " +
+                    prop.getType().getName());
+                // TODO abort?
+            }
+        }
+    }
+
+    // TODO comment
+    private static List<org.w3c.dom.Element> getMatchingChildNode(Type type,
+                                                                  org.w3c.dom.Element parentNode)
+    {
+        return getMachingChildNode(type.getName(), parentNode);
+    }
+
+    // TODO comment
+    private static List<org.w3c.dom.Element> getMatchingChildNode(Property prop,
+                                                                  org.w3c.dom.Element parentNode)
+    {
+        return getMachingChildNode(prop.getName(), parentNode);
+    }
+
+    // TODO comment
+    private static List<org.w3c.dom.Element> getMachingChildNode(String typeNameRaw,
+                                                                 org.w3c.dom.Element parentNode)
+    {
+        List<org.w3c.dom.Element> matchingNodes = new ArrayList<>();
+        Node parameterNode = null;
+        if (parentNode != null) {
+            NodeList parameterNodes = parentNode.getChildNodes();
+            String[] typeNameSplit = typeNameRaw.split(":");
+            String typeName = typeNameSplit[typeNameSplit.length - 1];
+            for (int i = 0; i < parameterNodes.getLength(); i++) {
+                parameterNode = parameterNodes.item(i);
+                if (parameterNode.getNodeType() == Node.ELEMENT_NODE) {
+                    String[] parameterNodeSplit = parameterNode.getNodeName().split(":");
+                    String parameterNodeName = parameterNodeSplit[parameterNodeSplit.length - 1];
+                    if (typeName.equals(parameterNodeName)) {
+                        matchingNodes.add((org.w3c.dom.Element) parameterNode);
+                    }
+                }
+            }
+            /*
+             * if( !matchingSOAPFound) { Console.traceln(Level.WARNING,
+             * "could not look up name of parameter in SOAP request: " + typeName); if(
+             * elementCount==0 ) { Console.traceln(Level.INFO, "\tno parameters found"); } else {
+             * Console.traceln(Level.INFO, "\tparameters found:"); for( int i=0 ;
+             * i<parameterNodes.getLength(); i++ ) { if(
+             * parameterNodes.item(i).getNodeType()==Node.ELEMENT_NODE ) {
+             * Console.traceln(Level.INFO, "\t\t" + parameterNodes.item(i).getNodeName()); } } }
+             * Console.traceln(Level.WARNING,
+             * "using dummy values for this parameter (and nested values) instead"); }
+             */
+        }
+        return matchingNodes;
+    }
+
+    // TODO
+    private static List<String> getPrimitiveTypeValuesFromElement(Property prop,
+                                                                  org.w3c.dom.Element currentNode)
+    {
+        List<String> attributeValues = new LinkedList<>();
+
+        if (currentNode != null) {
+            // first check attributes of the node
+            Attr attribute = currentNode.getAttributeNode(prop.getName());
+            if (attribute != null) {
+                attributeValues.add(attribute.getValue());
+            }
+            else {
+                // now check elements
+                List<org.w3c.dom.Element> elements = getMatchingChildNode(prop, currentNode);
+                for (org.w3c.dom.Element element : elements) {
+                    attributeValues.add(element.getTextContent());
+                }
+            }
+        }
+
+        return attributeValues;
+    }
+
 }