Ignore:
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:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/autoquest-plugin-uml/src/main/java/de/ugoe/cs/autoquest/plugin/uml/UMLUtils.java

    r1916 r1926  
    1515package de.ugoe.cs.autoquest.plugin.uml; 
    1616 
     17import java.io.StringWriter; 
     18import java.util.ArrayList; 
    1719import java.util.Collection; 
    1820import java.util.Collections; 
     
    3032import java.util.TreeSet; 
    3133 
     34import javax.xml.transform.Transformer; 
     35import javax.xml.transform.TransformerException; 
     36import javax.xml.transform.TransformerFactory; 
     37import javax.xml.transform.TransformerFactoryConfigurationError; 
     38import javax.xml.transform.dom.DOMSource; 
     39import javax.xml.transform.stream.StreamResult; 
     40 
    3241import org.eclipse.emf.common.util.EList; 
     42import org.eclipse.emf.common.util.URI; 
    3343import org.eclipse.uml2.uml.Activity; 
    3444import org.eclipse.uml2.uml.ActivityEdge; 
    3545import org.eclipse.uml2.uml.ActivityNode; 
    3646import org.eclipse.uml2.uml.CallConcurrencyKind; 
     47import org.eclipse.uml2.uml.CallEvent; 
    3748import org.eclipse.uml2.uml.CallOperationAction; 
    3849import org.eclipse.uml2.uml.Comment; 
     
    6677import org.eclipse.uml2.uml.Property; 
    6778import org.eclipse.uml2.uml.Region; 
     79import org.eclipse.uml2.uml.Relationship; 
    6880import org.eclipse.uml2.uml.Slot; 
    6981import org.eclipse.uml2.uml.StateMachine; 
    7082import org.eclipse.uml2.uml.Stereotype; 
    7183import org.eclipse.uml2.uml.Transition; 
     84import org.eclipse.uml2.uml.Trigger; 
     85import org.eclipse.uml2.uml.Type; 
    7286import org.eclipse.uml2.uml.UMLPackage; 
    7387import org.eclipse.uml2.uml.Vertex; 
     88import org.w3c.dom.Attr; 
     89import org.w3c.dom.Node; 
     90import org.w3c.dom.NodeList; 
    7491 
    7592import de.ugoe.cs.autoquest.eventcore.Event; 
     93import de.ugoe.cs.autoquest.plugin.http.SOAPUtils; 
    7694import de.ugoe.cs.autoquest.plugin.http.eventcore.SOAPEventType; 
    7795import de.ugoe.cs.autoquest.plugin.http.eventcore.SimpleSOAPEventType; 
    7896import de.ugoe.cs.autoquest.plugin.uml.eventcore.UMLTransitionType; 
    7997import de.ugoe.cs.autoquest.usageprofiles.IStochasticProcess; 
     98import de.ugoe.cs.util.StringTools; 
    8099import de.ugoe.cs.util.console.Console; 
    81100 
     
    88107 */ 
    89108public class UMLUtils { 
     109 
     110    /** 
     111     * In case a multiplicity is defined as *, this value defines the highest one that can be picked 
     112     */ 
     113    final static int MAX_MULTIPLICITY = 10; 
     114 
     115    final public static URI UML_PRIMITIVE_TYPES_URI = URI 
     116        .createURI("pathmap://UML_LIBRARIES/UMLPrimitiveTypes.library.uml", true); 
    90117 
    91118    /** 
     
    135162        for (List<Event> sequence : sequences) { 
    136163            for (Event event : sequence) { 
    137                 String serviceName = getServiceNameFromEvent(event); 
    138                 String calledMethod = getCalledMethodFromEvent(event); 
    139                 if( serviceName!=null ) { 
     164                String serviceName = SOAPUtils.getServiceNameFromEvent(event); 
     165                String calledMethod = SOAPUtils.getCalledMethodFromEvent(event); 
     166                if (serviceName != null) { 
    140167                    Set<String> curCalledMethods = calledMethods.get(serviceName); 
    141168                    if (curCalledMethods == null) { 
     
    152179        for (Entry<String, Set<String>> entry : calledMethods.entrySet()) { 
    153180            Console.traceln(Level.INFO, "\tService \"" + entry.getKey() + "\": "); 
    154             for(String method : entry.getValue()) { 
    155                 Console.traceln(Level.INFO, "\t\t"+method); 
     181            for (String method : entry.getValue()) { 
     182                Console.traceln(Level.INFO, "\t\t" + method); 
    156183            } 
    157184        } 
     
    204231                                    "\tFound the following realized interfaces for the service \"" + 
    205232                                        serviceName + "\": "); 
    206                     for( Interface intface : interfaces ) { 
     233                    for (Interface intface : interfaces) { 
    207234                        Console.traceln(Level.INFO, "\t" + intface.getName()); 
    208                         for( Operation operation : intface.getAllOperations() ) { 
     235                        for (Operation operation : intface.getAllOperations()) { 
    209236                            Console.traceln(Level.INFO, "\t\t" + operation.getName()); 
    210237                        } 
     
    235262     * <p> 
    236263     * Creates a sequence of events with {@link UMLTransitionType} as event type from a given 
    237      * sequence of events with the {@link SOAPEventType}, by matching the sequences to a state 
    238      * machine. 
     264     * sequence of events with the {@link SOAPEventType} or {@link SimpleSOAPEventType}, by matching 
     265     * the sequences to a state machine. 
    239266     * </p> 
    240267     *  
     
    248275                                                          StateMachine stateMachine) 
    249276    { 
     277        System.out.println("foo"); 
    250278        List<List<Transition>> matchingSequences = 
    251279            determineMatchingTransitionSequences(sequence, stateMachine); 
     280        System.out.println(matchingSequences.size()); 
    252281 
    253282        if (matchingSequences.size() != 1) { 
     
    370399        for (Iterator<Event> eventIterator = sequence.iterator(); eventIterator.hasNext();) { 
    371400            Event event = eventIterator.next(); 
    372             if (event.getType() instanceof SOAPEventType) { 
    373                 SOAPEventType eventType = (SOAPEventType) event.getType(); 
    374                 if (matchingSequences == null) { 
    375                     matchingSequences = new LinkedList<>(); 
    376                     List<Transition> initialMatches = matchTransitions(allTransitions, eventType); 
    377                     for (Transition transition : initialMatches) { 
    378                         List<Transition> candidate = new LinkedList<>(); 
    379                         candidate.add(transition); 
    380                         matchingSequences.add(candidate); 
    381                     } 
    382                     currentTransitions = initialMatches; 
    383                 } 
    384                 else { 
    385                     List<List<Transition>> nextMatchingSequences = new LinkedList<>(); 
    386                     List<Transition> nextCurrentTransitions = new LinkedList<>(); 
    387                     Iterator<Transition> currentTransitionIterator = currentTransitions.iterator(); 
    388                     Iterator<List<Transition>> currentMatchingSequencesIterator = 
    389                         matchingSequences.iterator(); 
    390                     while (currentTransitionIterator.hasNext()) { 
    391                         Transition currentTransition = currentTransitionIterator.next(); 
    392                         List<Transition> currentMatch = currentMatchingSequencesIterator.next(); 
    393  
    394                         List<Transition> matches = 
    395                             matchTransitions(currentTransition.getTarget().getOutgoings(), 
    396                                              eventType); 
    397                         if (matches.isEmpty()) { 
    398                             throw new RuntimeException("no matches found"); 
    399                         } 
    400                         for (Transition matchingTransition : matches) { 
    401                             List<Transition> candidate = new LinkedList<>(currentMatch); 
    402                             candidate.add(matchingTransition); 
    403                             nextMatchingSequences.add(candidate); 
    404                             nextCurrentTransitions.add(matchingTransition); 
    405                         } 
    406                     } 
    407                     matchingSequences = nextMatchingSequences; 
    408                     currentTransitions = nextCurrentTransitions; 
    409                 } 
     401            System.out.println(event); 
     402            System.out.println(matchingSequences); 
     403            if (matchingSequences == null) { 
     404                matchingSequences = new LinkedList<>(); 
     405                List<Transition> initialMatches = matchTransitions(allTransitions, event); 
     406                for (Transition transition : initialMatches) { 
     407                    List<Transition> candidate = new LinkedList<>(); 
     408                    candidate.add(transition); 
     409                    matchingSequences.add(candidate); 
     410                } 
     411                currentTransitions = initialMatches; 
    410412            } 
    411413            else { 
    412                 throw new RuntimeException( 
    413                                            "Wrong event type. Only UMLTransitionType supported but was: " + 
    414                                                event.getType().getClass().getName()); 
     414                List<List<Transition>> nextMatchingSequences = new LinkedList<>(); 
     415                List<Transition> nextCurrentTransitions = new LinkedList<>(); 
     416                Iterator<Transition> currentTransitionIterator = currentTransitions.iterator(); 
     417                Iterator<List<Transition>> currentMatchingSequencesIterator = 
     418                    matchingSequences.iterator(); 
     419                while (currentTransitionIterator.hasNext()) { 
     420                    Transition currentTransition = currentTransitionIterator.next(); 
     421                    List<Transition> currentMatch = currentMatchingSequencesIterator.next(); 
     422 
     423                    List<Transition> matches = 
     424                        matchTransitions(currentTransition.getTarget().getOutgoings(), event); 
     425                    if (matches.isEmpty()) { 
     426                        throw new RuntimeException("no matches found"); 
     427                    } 
     428                    for (Transition matchingTransition : matches) { 
     429                        List<Transition> candidate = new LinkedList<>(currentMatch); 
     430                        candidate.add(matchingTransition); 
     431                        nextMatchingSequences.add(candidate); 
     432                        nextCurrentTransitions.add(matchingTransition); 
     433                    } 
     434                } 
     435                matchingSequences = nextMatchingSequences; 
     436                currentTransitions = nextCurrentTransitions; 
    415437            } 
    416438        } 
     
    444466        final Stereotype utpTestContext = (Stereotype) utpProfile.getOwnedMember("TestContext"); 
    445467 
     468        // add UML Primitive types 
     469        // final UMLResource umlRes = (UMLResource) 
     470        // model.eResource().getResourceSet().getResource(UML_PRIMITIVE_TYPES_URI, true); 
     471        // model = (Model) umlRes.getContents().get(0); 
     472 
    446473        Component testContext = fetchTestContext(model, utpTestContext, testContextName); 
    447474        if (testContext == null) { 
     
    485512        for (Event event : sequence) { 
    486513            if (!(event.equals(Event.STARTEVENT) || event.equals(Event.ENDEVENT))) { 
    487                 String serviceName = getServiceNameFromEvent(event); 
    488                 String methodName = getCalledMethodFromEvent(event); 
    489                 String clientName = getClientNameFromEvent(event); 
     514                String serviceName = SOAPUtils.getServiceNameFromEvent(event); 
     515                String methodName = SOAPUtils.getCalledMethodFromEvent(event); 
     516                String clientName = SOAPUtils.getClientNameFromEvent(event); 
     517                String prefix = interactionName + ":" + i + ":" + methodName + "_"; 
    490518                // determine lifelines 
    491519                Lifeline msgTargetLifeline; 
    492520                Lifeline msgSourceLifeline; 
    493                  
     521 
    494522                msgSourceLifeline = interaction.getLifeline(clientName); 
    495523                msgTargetLifeline = interaction.getLifeline(serviceName); 
    496                  
     524 
    497525                if (msgSourceLifeline == null) { 
    498526                    throw new RuntimeException( 
    499                                                "Error creating message: could not determine source lifeline for component: " + clientName); 
     527                                               "Error creating message: could not determine source lifeline for component: " + 
     528                                                   clientName); 
    500529                } 
    501530                if (msgTargetLifeline == null) { 
    502531                    throw new RuntimeException( 
    503                                                "Error creating message: could not determine target lifeline for component: " + serviceName); 
     532                                               "Error creating message: could not determine target lifeline for component: " + 
     533                                                   serviceName); 
    504534                } 
    505535                // determine correct target interface 
     
    541571                // setup for both SYNCH and ASYNCH calls 
    542572                MessageOccurrenceSpecification callSendFragment = 
    543                     (MessageOccurrenceSpecification) interaction 
    544                         .createFragment(i + ":" + methodName + "_callSendFragment", 
    545                                         UMLPackage.Literals.MESSAGE_OCCURRENCE_SPECIFICATION); 
     573                    (MessageOccurrenceSpecification) interaction.createFragment(prefix + 
     574                        "callSendFragment", UMLPackage.Literals.MESSAGE_OCCURRENCE_SPECIFICATION); 
    546575                MessageOccurrenceSpecification callRecvFragment = 
    547                     (MessageOccurrenceSpecification) interaction 
    548                         .createFragment(i + ":" + methodName + "_callRecvFragment", 
    549                                         UMLPackage.Literals.MESSAGE_OCCURRENCE_SPECIFICATION); 
     576                    (MessageOccurrenceSpecification) interaction.createFragment(prefix + 
     577                        "callRecvFragment", UMLPackage.Literals.MESSAGE_OCCURRENCE_SPECIFICATION); 
    550578 
    551579                callSendFragment.setCovered(msgSourceLifeline); 
     
    554582                // create call 
    555583                Message callMessage = interaction.createMessage(methodName); 
    556                 callMessage.setSignature(calledOperation);  
    557                 setMessageParameters(callMessage, calledOperation, event); 
     584                callMessage.setSignature(calledOperation); 
     585                setMessageParameters(callMessage, calledOperation, event, prefix); 
    558586                callMessage.setConnector(inferConnector(msgSourceLifeline, msgTargetLifeline)); 
    559587                callMessage.setSendEvent(callSendFragment); 
     
    577605                    MessageOccurrenceSpecification replySendFragment = 
    578606                        (MessageOccurrenceSpecification) interaction 
    579                             .createFragment(i + ":" + methodName + "_replySendFragment", 
     607                            .createFragment(prefix + "replySendFragment", 
    580608                                            UMLPackage.Literals.MESSAGE_OCCURRENCE_SPECIFICATION); 
    581609                    MessageOccurrenceSpecification replyRecvFragment = 
    582610                        (MessageOccurrenceSpecification) interaction 
    583                             .createFragment(i + ":" + methodName + "_replyRecvFragment", 
     611                            .createFragment(prefix + "replyRecvFragment", 
    584612                                            UMLPackage.Literals.MESSAGE_OCCURRENCE_SPECIFICATION); 
    585613 
     
    618646    } 
    619647 
    620      
    621  
    622648    /** 
    623649     * <p> 
     
    653679                            .getName(); 
    654680                } 
    655                 eventSequence.add(new Event(new SimpleSOAPEventType(methodName, serviceName,""))); // TODO add client name 
     681                // eventSequence.add(new Event(new SimpleSOAPEventType(methodName, serviceName, "", 
     682                // ))); // TODO 
     683                // add 
     684                // client 
     685                // name 
    656686            } 
    657687        } 
     
    755785        } 
    756786        return result; 
    757     } 
    758  
    759     /** 
    760      * <p> 
    761      * Helper function to get the name of a service from a SOAP event. 
    762      * </p> 
    763      *  
    764      * @param event 
    765      *            event for which the service name is retrieved 
    766      * @return service name 
    767      */ 
    768     protected static String getServiceNameFromEvent(Event event) { 
    769         if (event.getType() instanceof SOAPEventType) { 
    770             return ((SOAPEventType) event.getType()).getServiceName(); 
    771         } 
    772         else if (event.getType() instanceof SimpleSOAPEventType) { 
    773             return ((SimpleSOAPEventType) event.getType()).getServiceName(); 
    774         } 
    775         else { 
    776             throw new RuntimeException( 
    777                                        "Wrong event type. Only SOAPEventType and SimpleSOAPEventType supported but was: " + 
    778                                            event.getType().getClass().getName()); 
    779         } 
    780     } 
    781  
    782     /** 
    783      *  
    784      * <p> 
    785      * Helper function to get the called method from a SOAP event 
    786      * </p> 
    787      *  
    788      * @param event 
    789      *            event for which the called method is retrieved 
    790      * @return called method 
    791      */ 
    792     private static String getCalledMethodFromEvent(Event event) { 
    793         if (event.getType() instanceof SOAPEventType) { 
    794             return ((SOAPEventType) event.getType()).getCalledMethod(); 
    795         } 
    796         else if (event.getType() instanceof SimpleSOAPEventType) { 
    797             return ((SimpleSOAPEventType) event.getType()).getCalledMethod(); 
    798         } 
    799         else { 
    800             throw new RuntimeException( 
    801                                        "Wrong event type. Only SOAPEventType and SimpleSOAPEventType supported but was: " + 
    802                                            event.getType().getClass().getName()); 
    803         } 
    804     } 
    805      
    806     /** 
    807      * <p> 
    808      * Helper function to get the name of a client from a SOAP event. 
    809      * </p> 
    810      *  
    811      * @param event 
    812      *            event for which the client name is retrieved 
    813      * @return service name 
    814      */ 
    815     protected static String getClientNameFromEvent(Event event) { 
    816         if (event.getType() instanceof SOAPEventType) { 
    817             return ((SOAPEventType) event.getType()).getClientName(); 
    818         } 
    819         else if (event.getType() instanceof SimpleSOAPEventType) { 
    820             return ((SimpleSOAPEventType) event.getType()).getClientName(); 
    821         } 
    822         else { 
    823             throw new RuntimeException( 
    824                                        "Wrong event type. Only SOAPEventType and SimpleSOAPEventType supported but was: " + 
    825                                            event.getType().getClass().getName()); 
    826         } 
    827787    } 
    828788 
     
    864824     * @return matching transitions 
    865825     */ 
    866     private static List<Transition> matchTransitions(List<Transition> transitions, 
    867                                                      SOAPEventType eventType) 
    868     { 
     826    private static List<Transition> matchTransitions(List<Transition> transitions, Event event) { 
     827        String eventService = SOAPUtils.getServiceNameFromEvent(event); 
     828        String eventMethod = SOAPUtils.getCalledMethodFromEvent(event); 
     829 
     830        Map<Interface, String> interfaceServiceMap = 
     831            createInterfaceServiceMap(transitions.get(0).getModel()); 
     832 
    869833        List<Transition> matching = new LinkedList<>(); 
    870834        for (Transition transition : transitions) { 
    871             // String serviceName = transition.getName().split("\\.")[0]; // TODO service name check 
    872             String methodName = transition.getName().split("\\.")[1]; 
    873             if (methodName.equals(eventType.getCalledMethod())) { 
    874                 matching.add(transition); 
    875             } 
     835            EList<Trigger> triggers = transition.getTriggers(); 
     836            if (triggers.size() == 1) { 
     837                if (triggers.get(0).getEvent() instanceof CallEvent) { 
     838                    CallEvent callEvent = (CallEvent) triggers.get(0).getEvent(); 
     839                    String transitionMethod = callEvent.getOperation().getName(); 
     840 
     841                    Interface intface = callEvent.getOperation().getInterface(); 
     842                    for (Relationship relationship : intface.getRelationships()) { 
     843                        for (Element element : relationship.getRelatedElements()) { 
     844                            if (element instanceof Component) { 
     845 
     846                            } 
     847                        } 
     848                    } 
     849 
     850                    String transitionService = 
     851                        interfaceServiceMap.get(callEvent.getOperation().getInterface()); 
     852                    if (eventMethod.equals(transitionMethod) && 
     853                        eventService.equals(transitionService)) 
     854                    { 
     855                        matching.add(transition); 
     856                    } 
     857                } 
     858            } 
     859 
    876860        } 
    877861        return matching; 
     
    970954        return null; 
    971955    } 
    972      
    973     private static void setMessageParameters(Message callMessage, Operation calledOperation, Event event) { 
     956 
     957    private static Map<Interface, String> createInterfaceServiceMap(Model model) { 
     958        Map<Interface, String> interfaceServiceMap = new HashMap<>(); 
     959        final Profile utpProfile = model.getModel().getAppliedProfile("utp"); 
     960        final Stereotype utpTestComponent = (Stereotype) utpProfile.getOwnedMember("TestComponent"); 
     961        final Stereotype utpSUT = (Stereotype) utpProfile.getOwnedMember("SUT"); 
     962        final Stereotype utpTestContext = (Stereotype) utpProfile.getOwnedMember("TestContext"); 
     963        List<Component> testContexts = 
     964            fetchTestContextRecursively(model.getModel(), utpTestContext); 
     965        for (Component testContext : testContexts) { 
     966            for (Property property : testContext.getAllAttributes()) { 
     967                if (property.getAppliedStereotypes().contains(utpSUT) || 
     968                    property.getType().getAppliedStereotypes().contains(utpTestComponent)) 
     969                { 
     970                    for (Interface intface : getRealizedInterfacesFromProperty(property)) { 
     971                        interfaceServiceMap.put(intface, property.getName()); 
     972                    } 
     973                } 
     974            } 
     975        } 
     976        return interfaceServiceMap; 
     977    } 
     978 
     979    private static void setMessageParameters(Message callMessage, 
     980                                             Operation calledOperation, 
     981                                             Event event, 
     982                                             String prefix) 
     983    { 
     984        org.w3c.dom.Element requestBody = SOAPUtils.getSoapRequestBodyFromEvent(event); 
     985 
    974986        // Set parameters of operation 
    975         for( Parameter param : calledOperation.getOwnedParameters() ) { 
    976             Expression argument = (Expression) callMessage.createArgument(param.getName(), param.getType(), UMLPackage.Literals.EXPRESSION); 
    977              
    978             if( param.getDirection()==ParameterDirectionKind.IN_LITERAL || param.getDirection()==ParameterDirectionKind.INOUT_LITERAL) { 
    979                 if( param.getType() instanceof DataType ) { 
    980                     InstanceSpecification instSpec = createInstanceSpecification((DataType) param.getType(), event); 
    981                      
    982                     InstanceValue value = (InstanceValue) argument.createOperand(null, param.getType(), UMLPackage.Literals.INSTANCE_VALUE); 
    983                     value.setInstance(instSpec); 
    984                 } 
    985                 else if( param.getType() instanceof PrimitiveType ) { 
    986                     if( "String".equals(param.getType().getName()) ) { 
    987                         LiteralString spec = (LiteralString) argument.createOperand(param.getName(), null, UMLPackage.Literals.LITERAL_STRING); 
    988                         spec.setValue("foobar"); // TODO needs to be real value 
    989                     } 
    990                     else if( "Integer".equals(param.getType().getName()) ) { 
    991                         LiteralInteger spec = (LiteralInteger) argument.createOperand(param.getName(), null, UMLPackage.Literals.LITERAL_INTEGER); 
    992                         spec.setValue(42); // TODO needs to be real value 
    993                     } 
    994                     else if( "Boolean".equals(param.getType().getName()) ) { 
    995                         LiteralBoolean spec = (LiteralBoolean) argument.createOperand(param.getName(), null, UMLPackage.Literals.LITERAL_BOOLEAN); 
    996                         spec.setValue(true); // TODO needs to be real value 
    997                     } 
    998                     else if( "Real".equals(param.getType().getName()) ) { 
    999                         LiteralReal spec = (LiteralReal) argument.createOperand(param.getName(), null, UMLPackage.Literals.LITERAL_REAL); 
    1000                         spec.setValue(3.14); // TODO needs to be real value 
    1001                     } 
    1002                 } 
    1003             } else { 
     987        for (Parameter param : calledOperation.getOwnedParameters()) { 
     988            Expression argument = 
     989                (Expression) callMessage.createArgument(param.getName(), param.getType(), 
     990                                                        UMLPackage.Literals.EXPRESSION); 
     991 
     992            if (param.getDirection() == ParameterDirectionKind.IN_LITERAL || 
     993                param.getDirection() == ParameterDirectionKind.INOUT_LITERAL) 
     994            { 
     995                if (param.getType() instanceof DataType) { 
     996                    List<org.w3c.dom.Element> paramNodes = 
     997                        getMatchingChildNode((DataType) param.getType(), requestBody); 
     998                    for (org.w3c.dom.Element paramNode : paramNodes) { 
     999                        InstanceSpecification instSpec = 
     1000                            createInstanceSpecification((DataType) param.getType(), event, prefix, 
     1001                                                        paramNode, ""); 
     1002 
     1003                        InstanceValue value = 
     1004                            (InstanceValue) argument 
     1005                                .createOperand(null, param.getType(), 
     1006                                               UMLPackage.Literals.INSTANCE_VALUE); 
     1007                        value.setInstance(instSpec); 
     1008                    } 
     1009                } 
     1010                else if (param.getType() instanceof PrimitiveType) { 
     1011                    createOperandPrimitiveType(param, argument, requestBody); 
     1012                } 
     1013            } 
     1014            else { 
    10041015                // set literalNull for out and return parameters 
    10051016                argument.createOperand(null, param.getType(), UMLPackage.Literals.LITERAL_NULL); 
     
    10071018        } 
    10081019    } 
    1009      
    1010     public static InstanceSpecification createInstanceSpecification(DataType type, Event event) { 
     1020 
     1021    private static InstanceSpecification createInstanceSpecification(DataType type, 
     1022                                                                     Event event, 
     1023                                                                     String prefix, 
     1024                                                                     org.w3c.dom.Element currentNode, 
     1025                                                                     String path) 
     1026    { 
     1027        if ("".equals(path)) { 
     1028            path = type.getName(); 
     1029        } 
     1030        // System.out.println(path); 
    10111031        String pkgUBTInstSpecs = "UBT_InstanceSpecifications"; 
    10121032        Model model = type.getModel(); 
    10131033        Package ubtInstSpecPkg = (Package) model.getOwnedMember(pkgUBTInstSpecs); 
    1014         if( ubtInstSpecPkg==null ) { 
    1015             ubtInstSpecPkg = (Package) type.getModel().createPackagedElement(pkgUBTInstSpecs, UMLPackage.Literals.PACKAGE); 
    1016         } 
    1017         String serviceName = getServiceNameFromEvent(event); 
     1034        if (ubtInstSpecPkg == null) { 
     1035            ubtInstSpecPkg = 
     1036                (Package) type.getModel().createPackagedElement(pkgUBTInstSpecs, 
     1037                                                                UMLPackage.Literals.PACKAGE); 
     1038        } 
     1039        String serviceName = SOAPUtils.getServiceNameFromEvent(event); 
    10181040        Package serviceInstSpecPkg = (Package) ubtInstSpecPkg.getOwnedMember(serviceName); 
    1019         if( serviceInstSpecPkg==null ) { 
    1020             serviceInstSpecPkg = (Package) ubtInstSpecPkg.createPackagedElement(serviceName, UMLPackage.Literals.PACKAGE); 
    1021         } 
    1022          
    1023         InstanceSpecification instSpec = (InstanceSpecification) serviceInstSpecPkg.createPackagedElement("instspec_"+type.getName(), UMLPackage.Literals.INSTANCE_SPECIFICATION); 
     1041        if (serviceInstSpecPkg == null) { 
     1042            serviceInstSpecPkg = 
     1043                (Package) ubtInstSpecPkg.createPackagedElement(serviceName, 
     1044                                                               UMLPackage.Literals.PACKAGE); 
     1045        } 
     1046 
     1047        InstanceSpecification instSpec = 
     1048            (InstanceSpecification) serviceInstSpecPkg.createPackagedElement(prefix + "instspec_" + 
     1049                type.getName(), UMLPackage.Literals.INSTANCE_SPECIFICATION); 
    10241050        instSpec.getClassifiers().add(type); 
    1025         for( Property prop : type.getAllAttributes() ) { 
    1026             // TODO handle multiplicity 
    1027             //int lowerBound = prop.getLower(); 
    1028             //int upperBound = prop.getUpper(); 
    1029              
     1051        for (Property prop : type.getAllAttributes()) { 
     1052            if (prop.getType() instanceof PrimitiveType) { 
     1053                createSlotPrimitiveType(instSpec, prop, currentNode, path); 
     1054            } 
     1055            else if (prop.getType() instanceof DataType) { 
     1056                List<org.w3c.dom.Element> attributeNodes = null; 
     1057                int multiplicityChosen = 0; 
     1058                if (currentNode != null) { 
     1059                    attributeNodes = getMatchingChildNode(prop, currentNode); 
     1060                    multiplicityChosen = attributeNodes.size(); 
     1061                } 
     1062 
     1063                if (multiplicityChosen == 0 && prop.getLower() > 0) { 
     1064                    if (currentNode != null) { 
     1065                        Console.traceln(Level.WARNING, 
     1066                                        "required attribute not found in SOAP message: " + path + 
     1067                                            "." + prop.getName()); 
     1068                        Console 
     1069                            .traceln(Level.WARNING, 
     1070                                     "setting default values for this attribute and all its children"); 
     1071                        Console.traceln(Level.FINE, "XML structure of path:" + StringTools.ENDLINE + 
     1072                            SOAPUtils.getSerialization(currentNode)); 
     1073                    } 
     1074                    multiplicityChosen = prop.getLower(); 
     1075                } 
     1076                for (int i = 0; i < multiplicityChosen; i++) { 
     1077                    org.w3c.dom.Element attributeNode = null; 
     1078                    if (attributeNodes != null && !attributeNodes.isEmpty()) { 
     1079                        attributeNode = attributeNodes.get(i); 
     1080                    } 
     1081 
     1082                    Slot slot = instSpec.createSlot(); 
     1083                    slot.setDefiningFeature(prop); 
     1084 
     1085                    InstanceValue value = 
     1086                        (InstanceValue) slot.createValue(prop.getName() + "_" + i, prop.getType(), 
     1087                                                         UMLPackage.Literals.INSTANCE_VALUE); 
     1088                    value.setInstance(createInstanceSpecification((DataType) prop.getType(), event, 
     1089                                                                  prefix, attributeNode, path + 
     1090                                                                      "." + prop.getName())); 
     1091                } 
     1092            } 
     1093            else { 
     1094                Console.traceln(Level.SEVERE, "property neither DataType nor PrimitiveType: " + 
     1095                    prop.getType()); 
     1096                // TODO abort? 
     1097            } 
     1098        } 
     1099        return instSpec; 
     1100    } 
     1101 
     1102    private static void createOperandPrimitiveType(Parameter param, 
     1103                                                   Expression argument, 
     1104                                                   org.w3c.dom.Element currentNode) 
     1105    { 
     1106        if ("String".equals(param.getType().getName())) { 
     1107            LiteralString spec = 
     1108                (LiteralString) argument.createOperand(param.getName(), null, 
     1109                                                       UMLPackage.Literals.LITERAL_STRING); 
     1110            spec.setValue("foobar"); // TODO needs to be real value 
     1111        } 
     1112        else if ("Integer".equals(param.getType().getName())) { 
     1113            LiteralInteger spec = 
     1114                (LiteralInteger) argument.createOperand(param.getName(), null, 
     1115                                                        UMLPackage.Literals.LITERAL_INTEGER); 
     1116            spec.setValue(42); // TODO needs to be real value 
     1117        } 
     1118        else if ("Boolean".equals(param.getType().getName())) { 
     1119            LiteralBoolean spec = 
     1120                (LiteralBoolean) argument.createOperand(param.getName(), null, 
     1121                                                        UMLPackage.Literals.LITERAL_BOOLEAN); 
     1122            spec.setValue(true); // TODO needs to be real value 
     1123        } 
     1124        else if ("Real".equals(param.getType().getName())) { 
     1125            LiteralReal spec = 
     1126                (LiteralReal) argument.createOperand(param.getName(), null, 
     1127                                                     UMLPackage.Literals.LITERAL_REAL); 
     1128            spec.setValue(3.14); // TODO needs to be real value 
     1129        } 
     1130    } 
     1131 
     1132    private static void createSlotPrimitiveType(InstanceSpecification instSpec, 
     1133                                                Property prop, 
     1134                                                org.w3c.dom.Element currentNode, 
     1135                                                String path) 
     1136    { 
     1137        List<String> attributeValues = getPrimitiveTypeValuesFromElement(prop, currentNode); 
     1138 
     1139        if (attributeValues.isEmpty()) { 
     1140            if (prop.getLower() == 0) { 
     1141                // ignoring optional attribute 
     1142                return; 
     1143            } 
     1144            else { 
     1145                if (currentNode != null) { 
     1146                    Console.traceln(Level.WARNING, 
     1147                                    "required attribute not found in SOAP message: " + path + "." + 
     1148                                        prop.getName()); 
     1149                    Console.traceln(Level.WARNING, "setting default values for this attribute"); 
     1150                } 
     1151                Console.traceln(Level.FINE, "XML structure of path:" + StringTools.ENDLINE + 
     1152                    SOAPUtils.getSerialization(currentNode)); 
     1153                attributeValues.add(null); 
     1154            } 
     1155        } 
     1156        for (String attributeValue : attributeValues) { 
    10301157            Slot slot = instSpec.createSlot(); 
    10311158            slot.setDefiningFeature(prop); 
    1032             if( prop.getType() instanceof PrimitiveType ) { 
    1033                 if( "String".equals(prop.getType().getName()) ) { 
    1034                     LiteralString value = (LiteralString) slot.createValue(prop.getName(), null, UMLPackage.Literals.LITERAL_STRING); 
    1035                     value.setValue("foobar"); // TODO needs to be real value 
    1036                 } 
    1037                 else if( "Integer".equals(prop.getType().getName()) ) { 
    1038                     LiteralInteger value = (LiteralInteger) slot.createValue(prop.getName(), null, UMLPackage.Literals.LITERAL_INTEGER); 
    1039                     value.setValue(42); // TODO needs to be real value 
    1040                 } 
    1041                 else if( "Boolean".equals(prop.getType().getName()) ) { 
    1042                     LiteralBoolean value = (LiteralBoolean) slot.createValue(prop.getName(), null, UMLPackage.Literals.LITERAL_BOOLEAN); 
    1043                     value.setValue(true); // TODO needs to be real value 
    1044                 } 
    1045                 else if( "Real".equals(prop.getType().getName()) ) { 
    1046                     LiteralReal value = (LiteralReal) slot.createValue(prop.getName(), null, UMLPackage.Literals.LITERAL_REAL); 
     1159            if ("String".equals(prop.getType().getName())) { 
     1160                LiteralString value = 
     1161                    (LiteralString) slot.createValue(prop.getName(), null, 
     1162                                                     UMLPackage.Literals.LITERAL_STRING); 
     1163                if (attributeValue != null) { 
     1164                    value.setValue(attributeValue); 
     1165                } 
     1166                else { 
     1167                    value.setValue("foobar"); 
     1168                } 
     1169            } 
     1170            else if ("Integer".equals(prop.getType().getName())) { 
     1171                LiteralInteger value = 
     1172                    (LiteralInteger) slot.createValue(prop.getName(), null, 
     1173                                                      UMLPackage.Literals.LITERAL_INTEGER); 
     1174                if (attributeValue != null) { 
     1175                    value.setValue(Integer.parseInt(attributeValue)); 
     1176                } 
     1177                else { 
     1178                    value.setValue(42); 
     1179                } 
     1180            } 
     1181            else if ("Boolean".equals(prop.getType().getName())) { 
     1182                LiteralBoolean value = 
     1183                    (LiteralBoolean) slot.createValue(prop.getName(), null, 
     1184                                                      UMLPackage.Literals.LITERAL_BOOLEAN); 
     1185                if (attributeValue != null) { 
     1186                    value.setValue(Boolean.parseBoolean(attributeValue)); 
     1187                } 
     1188                else { 
     1189                    value.setValue(true); 
     1190                } 
     1191            } 
     1192            else if ("Real".equals(prop.getType().getName())) { 
     1193                LiteralReal value = 
     1194                    (LiteralReal) slot.createValue(prop.getName(), null, 
     1195                                                   UMLPackage.Literals.LITERAL_REAL); 
     1196                if (attributeValue != null) { 
     1197                    value.setValue(Double.parseDouble(attributeValue)); 
     1198                } 
     1199                else { 
    10471200                    value.setValue(3.14); // TODO needs to be real value 
    10481201                } 
    10491202            } 
    1050             else if( prop.getType() instanceof DataType ) { 
    1051                 InstanceValue value = (InstanceValue) slot.createValue(prop.getName(), prop.getType(), UMLPackage.Literals.INSTANCE_VALUE); 
    1052                 value.setInstance(createInstanceSpecification((DataType) prop.getType(), event)); 
    1053             } 
    1054         } 
    1055         return instSpec; 
    1056     } 
     1203            else { 
     1204                Console.traceln(Level.SEVERE, "could not create literal for primitive type: " + 
     1205                    prop.getType().getName()); 
     1206                // TODO abort? 
     1207            } 
     1208        } 
     1209    } 
     1210 
     1211    // TODO comment 
     1212    private static List<org.w3c.dom.Element> getMatchingChildNode(Type type, 
     1213                                                                  org.w3c.dom.Element parentNode) 
     1214    { 
     1215        return getMachingChildNode(type.getName(), parentNode); 
     1216    } 
     1217 
     1218    // TODO comment 
     1219    private static List<org.w3c.dom.Element> getMatchingChildNode(Property prop, 
     1220                                                                  org.w3c.dom.Element parentNode) 
     1221    { 
     1222        return getMachingChildNode(prop.getName(), parentNode); 
     1223    } 
     1224 
     1225    // TODO comment 
     1226    private static List<org.w3c.dom.Element> getMachingChildNode(String typeNameRaw, 
     1227                                                                 org.w3c.dom.Element parentNode) 
     1228    { 
     1229        List<org.w3c.dom.Element> matchingNodes = new ArrayList<>(); 
     1230        Node parameterNode = null; 
     1231        if (parentNode != null) { 
     1232            NodeList parameterNodes = parentNode.getChildNodes(); 
     1233            String[] typeNameSplit = typeNameRaw.split(":"); 
     1234            String typeName = typeNameSplit[typeNameSplit.length - 1]; 
     1235            for (int i = 0; i < parameterNodes.getLength(); i++) { 
     1236                parameterNode = parameterNodes.item(i); 
     1237                if (parameterNode.getNodeType() == Node.ELEMENT_NODE) { 
     1238                    String[] parameterNodeSplit = parameterNode.getNodeName().split(":"); 
     1239                    String parameterNodeName = parameterNodeSplit[parameterNodeSplit.length - 1]; 
     1240                    if (typeName.equals(parameterNodeName)) { 
     1241                        matchingNodes.add((org.w3c.dom.Element) parameterNode); 
     1242                    } 
     1243                } 
     1244            } 
     1245            /* 
     1246             * if( !matchingSOAPFound) { Console.traceln(Level.WARNING, 
     1247             * "could not look up name of parameter in SOAP request: " + typeName); if( 
     1248             * elementCount==0 ) { Console.traceln(Level.INFO, "\tno parameters found"); } else { 
     1249             * Console.traceln(Level.INFO, "\tparameters found:"); for( int i=0 ; 
     1250             * i<parameterNodes.getLength(); i++ ) { if( 
     1251             * parameterNodes.item(i).getNodeType()==Node.ELEMENT_NODE ) { 
     1252             * Console.traceln(Level.INFO, "\t\t" + parameterNodes.item(i).getNodeName()); } } } 
     1253             * Console.traceln(Level.WARNING, 
     1254             * "using dummy values for this parameter (and nested values) instead"); } 
     1255             */ 
     1256        } 
     1257        return matchingNodes; 
     1258    } 
     1259 
     1260    // TODO 
     1261    private static List<String> getPrimitiveTypeValuesFromElement(Property prop, 
     1262                                                                  org.w3c.dom.Element currentNode) 
     1263    { 
     1264        List<String> attributeValues = new LinkedList<>(); 
     1265 
     1266        if (currentNode != null) { 
     1267            // first check attributes of the node 
     1268            Attr attribute = currentNode.getAttributeNode(prop.getName()); 
     1269            if (attribute != null) { 
     1270                attributeValues.add(attribute.getValue()); 
     1271            } 
     1272            else { 
     1273                // now check elements 
     1274                List<org.w3c.dom.Element> elements = getMatchingChildNode(prop, currentNode); 
     1275                for (org.w3c.dom.Element element : elements) { 
     1276                    attributeValues.add(element.getTextContent()); 
     1277                } 
     1278            } 
     1279        } 
     1280 
     1281        return attributeValues; 
     1282    } 
     1283 
    10571284} 
Note: See TracChangeset for help on using the changeset viewer.