Ignore:
Timestamp:
09/07/12 15:21:30 (12 years ago)
Author:
fglaser
Message:
  • Interface for replayID calculation and corresponding test case extended
File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/quest-plugin-jfc/src/main/java/de/ugoe/cs/quest/plugin/jfc/JFCReplayIDCalculator.java

    r785 r796  
    11package de.ugoe.cs.quest.plugin.jfc; 
    22 
     3import java.util.ArrayList; 
    34import java.util.Arrays; 
    45import java.util.LinkedHashMap; 
    56import java.util.List; 
     7import java.util.ListIterator; 
    68import java.util.Map; 
    7 import java.util.Stack; 
    89import java.util.regex.Matcher; 
    910import java.util.regex.Pattern; 
     
    5051         "javax.swing.JScrollPane$ScrollBar", 
    5152         "javax.swing.plaf.metal.MetalScrollButton"); 
    52          
    53          
    54         /** 
    55          * Calculates the replayID needed for compatibility with Guitar suite of a JFCEvent 
     53    
     54   /** 
     55    * Calculates the replayID of a JFCEvent needed for compatibility with guitar suite 
     56    * @param List of {@link JFCGUIElementSpec}s that represent the component path of a event target 
     57    * for which the replayID should be calculated.  
     58    * @return replayID 
     59    */ 
     60         
     61   public String calculateReplayID(List<JFCGUIElementSpec> guiElementPath){ 
     62           String replayID = ""; 
     63           long hashCode = 1; 
     64          
     65           ListIterator<JFCGUIElementSpec> iterator = guiElementPath.listIterator(); 
     66            
     67           JFCGUIElementSpec currentSpec = iterator.next(); 
     68           String title = currentSpec.getName(); 
     69           String fuzzyTitle = getFuzzyTitle(title); 
     70           long windowHashCode = fuzzyTitle.hashCode(); 
     71           windowHashCode = (windowHashCode * 2) & 0xffffffffL; 
     72 
     73           long propagatedHashCode = windowHashCode; 
     74            
     75           // construct looks complicated but avoids going back and force through path 
     76           if (iterator.hasNext()) 
     77                   currentSpec = iterator.next(); 
     78           else 
     79                   currentSpec = null; 
     80 
     81           // walk through component path and calculate hashcode 
     82           while(currentSpec != null){ 
     83                   long localHashCode = getLocalHashCode(currentSpec); 
     84                   hashCode = propagatedHashCode * prime + localHashCode; 
     85                   hashCode = (hashCode * 2) & 0xffffffffL; 
     86 
     87                   if (iterator.hasNext()){ 
     88                           currentSpec = iterator.next(); 
     89                           Integer index = currentSpec.getIndex(); 
     90                           propagatedHashCode = prime * propagatedHashCode 
     91                                           + index.hashCode(); 
     92                   } 
     93                   else 
     94                           currentSpec = null; 
     95                            
     96           } 
     97 
     98           replayID = "e" + hashCode; 
     99 
     100           return replayID; 
     101   } 
     102    
     103    
     104        /** 
     105         * Calculates the replayID of a JFCEvent needed for compatibility with guitar suite  
    56106         * @param event for which the ID should be calculated 
    57107         * @return replayID 
    58108         */ 
    59109        public String calculateReplayID(Event event){ 
    60                 String replayID = ""; 
    61                 long hashCode = 1; 
    62                 Stack<JFCGUIElement> path = new Stack<JFCGUIElement>(); 
     110                List<JFCGUIElementSpec> guiElementPath = new ArrayList<JFCGUIElementSpec>(); 
    63111                 
    64112                IEventTarget target = event.getTarget(); 
    65113                JFCGUIElement jfcTarget = (JFCGUIElement) target; 
    66114                 
    67                 // extract target path 
     115                // extract element path 
    68116                JFCGUIElement currentTarget = jfcTarget; 
    69117                while (currentTarget != null){ 
    70                         path.push(currentTarget); 
     118                        JFCGUIElementSpec currentSpec = (JFCGUIElementSpec) currentTarget.getSpecification(); 
     119                        guiElementPath.add(0, currentSpec); 
    71120                        currentTarget = (JFCGUIElement) currentTarget.getParent(); 
    72121                } 
    73122                 
    74                 // calculate window hashcode 
    75                 currentTarget = path.pop(); 
    76                  
    77                 JFCGUIElementSpec currentSpec = (JFCGUIElementSpec) currentTarget.getSpecification(); 
    78                 String title = currentSpec.getName(); 
    79                 String fuzzyTitle = getFuzzyTitle(title); 
    80                 long windowHashCode = fuzzyTitle.hashCode(); 
    81                 windowHashCode = (windowHashCode * 2) & 0xffffffffL; 
    82                  
    83                 long propagatedHashCode = windowHashCode; 
    84                  
    85                 // walk through component path and calculate hashcode 
    86                  
    87                 while(!path.isEmpty()){ 
    88                         currentTarget = path.pop();  
    89                         currentSpec = (JFCGUIElementSpec) currentTarget.getSpecification(); 
    90                         long localHashCode = getLocalHashCode(currentSpec); 
    91                         hashCode = propagatedHashCode * prime + localHashCode; 
    92                 hashCode = (hashCode * 2) & 0xffffffffL; 
    93                          
    94                 if (!path.isEmpty()){ 
    95                         Integer index = ((JFCGUIElementSpec) path.lastElement().getSpecification()).getIndex(); 
    96                                 propagatedHashCode = prime * propagatedHashCode 
    97                                 + index.hashCode(); 
    98                 } 
    99                 } 
    100                  
    101                 replayID = "e" + hashCode; 
    102                  
    103                 return replayID; 
     123                // calculation is delegated to other calculateReplayID method 
     124                return this.calculateReplayID(guiElementPath); 
    104125        } 
    105126         
Note: See TracChangeset for help on using the changeset viewer.