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

Timestamp:

03/06/15 09:18:02 (9 years ago)

Author:

sherbold

Message:

• added validation function for models based on observed usage data
• Interaction generation now automatically decides if a call is SYNCH/ASYNCH based on the concurrency information of the operation that is called

File:

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

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

@@ -19 +19 @@
 import java.util.Comparator;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
@@ -25 +26 @@
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.logging.Level;
+import java.util.Set;
+import java.util.TreeSet;
 
 import org.eclipse.emf.common.util.EList;
@@ -30 +34 @@
 import org.eclipse.uml2.uml.ActivityEdge;
 import org.eclipse.uml2.uml.ActivityNode;
-import org.eclipse.uml2.uml.BehaviorExecutionSpecification;
+import org.eclipse.uml2.uml.CallConcurrencyKind;
 import org.eclipse.uml2.uml.CallOperationAction;
 import org.eclipse.uml2.uml.Comment;
@@ -62 +66 @@
 import de.ugoe.cs.autoquest.plugin.uml.eventcore.UMLTransitionType;
 import de.ugoe.cs.autoquest.usageprofiles.IStochasticProcess;
+import de.ugoe.cs.util.console.Console;
 
 /**
@@ -72 +77 @@
 public class UMLUtils {
 
+    public static void validateModelWithLog(Collection<List<Event>> sequences, Model model, String testContextName) {
+        final Profile utpProfile = model.getAppliedProfile("utp");
+        final Stereotype utpTestComponent = (Stereotype) utpProfile.getOwnedMember("TestComponent");
+        final Stereotype utpSUT = (Stereotype) utpProfile.getOwnedMember("SUT");
+        final Stereotype utpTestContext = (Stereotype) utpProfile.getOwnedMember("TestContext");
+
+        Component testContext = fetchTestContext(model, utpTestContext, testContextName);
+        if (testContext == null) {
+            if( testContextName==null ) {
+                Console.traceln(Level.SEVERE, "Could not find any TestContext in the model.");
+                
+            } else {
+                Console.traceln(Level.SEVERE, "Could not find TestContext in the model: " + testContextName);
+            }
+            Console.traceln(Level.SEVERE, "Hint: Check if you have applied the TestContext stereotype correctly in the model.");
+        }
+        
+        // Create list of unique methods calls
+        HashMap<String, Set<String>> calledMethods = new HashMap<>();
+        for( List<Event> sequence : sequences ) {
+            for( Event event : sequence ) {
+                if( event.getType() instanceof SOAPEventType ) {
+                    SOAPEventType eventType = (SOAPEventType) event.getType();
+                    Set<String> curCalledMethods = calledMethods.get(eventType.getServiceName());
+                    if( curCalledMethods==null ) {
+                        curCalledMethods = new TreeSet<>();
+                        calledMethods.put(eventType.getServiceName(), curCalledMethods);
+                    }
+                    curCalledMethods.add(eventType.getCalledMethod());
+                }
+            }
+        }
+        
+        Console.traceln(Level.INFO, "Found the following services and operations in the usage data: ");
+        for( Entry<String, Set<String>> entry : calledMethods.entrySet() ) {
+            Console.traceln(Level.INFO, "\tService \"" + entry.getKey() + "\": ");
+            Iterator<String> iter = entry.getValue().iterator();
+            StringBuilder strBld = new StringBuilder();
+            while (iter.hasNext()) {
+                strBld.append(iter.next());
+                if (iter.hasNext()) {
+                    strBld.append(", ");
+                }
+            }
+            Console.traceln(Level.INFO, strBld.toString());
+        }
+        
+        // fetch all SUTs and TestComponents
+        HashMap<String, Property> properties = new HashMap<>();
+        for (Property property : testContext.getAllAttributes()) {
+            if (property.getAppliedStereotypes().contains(utpSUT)) {
+                properties.put(property.getName(),property);
+            }
+            else if (property.getType().getAppliedStereotypes().contains(utpTestComponent)) {
+                properties.put(property.getName(),property);
+            }
+        }
+        Console.traceln(Level.INFO, "Found the following services in the TestConfiguration:");
+        for( Entry<String, Property> entry : properties.entrySet() ) {
+            Console.traceln(Level.INFO, "\t" + entry.getKey());
+        }
+        
+        for( Entry<String, Set<String>> entry : calledMethods.entrySet() ) {
+            String serviceName = entry.getKey();
+            Console.traceln(Level.INFO, "Checking service: " + serviceName);
+            Set<String> methodNames = entry.getValue();
+            Property property = properties.get(serviceName);
+            if( property==null ) {
+                Console.traceln(Level.SEVERE, "\tCould not find property for service: " + serviceName);
+                Console.traceln(Level.SEVERE, "\tHint: Check service name map and/or model if the service is present and spelled correctly.");
+                Console.traceln(Level.SEVERE, "\tHint: Check if the SUT/TestComponent stereotype has been applied correctly in this TestContext.");
+            } else {
+                Set<Interface> interfaces = getRealizedInterfacesFromProperty(property);
+                if( interfaces.isEmpty() ) {
+                    Console.traceln(Level.SEVERE, "\tCould not find any interfaces implementing the property for service: " + serviceName);
+                    Console.traceln(Level.SEVERE, "\tHint: Check if the property correctly realizes the interfaces in the model.");
+                } else {
+                    Console.traceln(Level.INFO, "\tFound the following realized interfaces for the service \"" + serviceName + "\": ");
+                    Iterator<Interface> iter = interfaces.iterator();   
+                    while (iter.hasNext()) {
+                        String interfaceName = iter.next().getName();
+                        StringBuilder strBld = new StringBuilder();
+                        strBld.append(interfaceName);
+                        if (iter.hasNext()) {
+                            strBld.append(", ");
+                        }
+                        Console.traceln(Level.INFO, strBld.toString());
+                    }
+                    for( String methodName : methodNames ) {
+                        boolean methodFound = true;
+                        for( Interface intface : interfaces ) {
+                            if (getOperationFromName(intface.getOperations(), methodName) != null) {
+                                // interface found
+                                Console.traceln(Level.INFO, "\tMethod " + methodName + " found in interface " + intface.getName() );
+                                methodFound = true;
+                            }
+                        }
+                        if( !methodFound ) {
+                            Console.traceln(Level.SEVERE, "\tCould not find operation: " + methodName);
+                            Console.traceln(Level.SEVERE, "\tHint: check if operation is present and spelled correctly");
+                        }
+                    }
+                }
+            }
+        }
+        
+    }
+    
     /**
      * <p>
@@ -355 +468 @@
                 }
                 // determine correct target interface
-                List<Interface> targetInterfaces =
+                Set<Interface> targetInterfaces =
                     getRealizedInterfacesFromProperty((Property) msgTargetLifeline.getRepresents());
                 if (targetInterfaces.isEmpty()) {
@@ -363 +476 @@
                 Interface targetInterface = null;
                 for (Interface intface : targetInterfaces) {
-                    System.out.println(intface.getOperations());
                     if (getOperationFromName(intface.getOperations(), methodName) != null) {
                         // interface found
@@ -412 +524 @@
                 callRecvFragment.setMessage(callMessage);
 
-                // TODO somehow infer if called operation is SYNCH or ASYNCH
-                // possibly requires additional stereotype
                 boolean asynch = false;
+                if( calledOperation.getConcurrency()==CallConcurrencyKind.CONCURRENT_LITERAL ) {
+                    asynch = true;
+                }
                 if (asynch) {
                     // Create ASYNCH call
@@ -700 +813 @@
     }
 
-    private static List<Interface> getRealizedInterfacesFromProperty(Property property) {
+    private static Set<Interface> getRealizedInterfacesFromProperty(Property property) {
         return getRealizedInterfaceFromComponent((Component) property.getType());
     }
 
-    private static List<Interface> getRealizedInterfaceFromComponent(Component comp) {
-        List<Interface> interfaces = new LinkedList<>();
+    private static Set<Interface> getRealizedInterfaceFromComponent(Component comp) {
+        Set<Interface> interfaces = new HashSet<>();
         // Interface myInterface = null;
         for (Property property : comp.getAttributes()) {