Changeset 171 for trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/EventGenerator.java

-                      r141
+                      r171
 import org.jdom.input.SAXBuilder;
+import de.ugoe.cs.eventbench.data.Event;
 import de.ugoe.cs.eventbench.windows.data.WindowTree;
 import de.ugoe.cs.eventbench.windows.data.WindowTreeNode;
 …
 /**
  * <p>
  * Translates sequences of windows messages into events that can be used by the
  * Logalyzer core libraries for usage analysis.
+ * Translates sequences of windows messages into {@link WindowsEvent}s that can
+ * be used by the EventBench core libraries.
  * </p>
+ *
  * @author Steffen Herbold
+ *
+ * @version 1.0
  */
 public class EventGenerator {
 …
+        }
+        private boolean createSequenceLParam(
+                        List<WindowsMessage> generatedMessageSeq, boolean msgsGenerated,
+                        int constMsgType, Element termElement)
+                        throws NoSuchElementException {
+                Iterator<WindowsMessage> seqIterator = generatedMessageSeq.iterator();
+                if (termElement.getName().equals("seqValue")) {
+                        String obj = termElement.getAttributeValue("seqObj");
+                        List<WindowsMessage> seqVar = getStoredSeqVariable(obj);
+                        if (msgsGenerated && seqVar.size() != generatedMessageSeq.size()) {
+                                throw new InvalidParameterException(
+                                                "Failure generating replay sequence for rule "
+                                                                + currentRuleName
+                                                                + ": One or more of the sequence variables used to generate a sequence have different lenghts.");
+                        }
+                        for (WindowsMessage msg : seqVar) {
+                                WindowsMessage currentSeqMsg = getCurrentSeqMsg(
+                                                generatedMessageSeq, msgsGenerated, constMsgType,
+                                                seqIterator);
+                                String paramValueStr = msg.getParameter(termElement
+                                                .getAttributeValue("param"));
+                                int paramValue = 0;
+                                try {
+                                        paramValue = Integer.parseInt(paramValueStr);
+                                        currentSeqMsg.setLPARAM(paramValue);
+                                } catch (NumberFormatException e) {
+                                        currentSeqMsg.setLPARAMasWindowDesc(paramValueStr);
+                                }
+                        }
+                        if (seqIterator.hasNext()) {
+                                // the first seq-var has a different number of elements than the
+                                // current one
+                                throw new NoSuchElementException();
+                        }
+                        msgsGenerated = true;
+                } else { // const value
+                        int paramValue = Integer.parseInt(getTermValue(null, termElement));
+                        while (seqIterator.hasNext()) {
+                                seqIterator.next().setLPARAM(paramValue);
+                        }
+                }
+                return msgsGenerated;
+        }
+        private boolean createSequenceTarget(
+                        List<WindowsMessage> generatedMessageSeq, boolean msgsGenerated,
+                        int constMsgType, Element termElement)
+                        throws NoSuchElementException {
+                Iterator<WindowsMessage> seqIterator = generatedMessageSeq.iterator();
+                if (termElement.getName().equals("seqValue")) {
+                        String obj = termElement.getAttributeValue("seqObj");
+                        List<WindowsMessage> seqVar = getStoredSeqVariable(obj);
+                        if (msgsGenerated && seqVar.size() != generatedMessageSeq.size()) {
+                                throw new InvalidParameterException(
+                                                "Failure generating replay sequence for rule "
+                                                                + currentRuleName
+                                                                + ": One or more of the sequence variables used to generate a sequence have different lenghts.");
+                        }
+                        for (WindowsMessage msg : seqVar) {
+                                WindowsMessage currentSeqMsg = getCurrentSeqMsg(
+                                                generatedMessageSeq, msgsGenerated, constMsgType,
+                                                seqIterator);
+                                String targetString = msg.getParameter(termElement
+                                                .getAttributeValue("param"));
+                                currentSeqMsg.setXmlWindowDescription(targetString);
+                        }
+                        msgsGenerated = true;
+                } else { // const value
+                        throw new AssertionError("target must be a sequence variable!");
+        // ////////////////////////////////////////////////////////////
+        // Helper functions for matching of events, i.e., msg-nodes //
+        // ////////////////////////////////////////////////////////////
+        /**
+         * <p>
+         * Handles msg-nodes where multiple is not true, i.e., not a sequences.
+         * </p>
+         *
+         * @param messageElement
+         *            {@link Element} representing the msg-node
+         * @return true, if a match is found; false otherwise
+         */
+        private boolean matchSingleMessage(Element messageElement) {
+                boolean isMatch = false;
+                WindowsMessage currentMessage = null;
+                int type = Integer.parseInt(messageElement.getAttributeValue("type"));
+                while (!isMatch && sequenceIterator.hasNext()) {
                         /*
+                         * If target would not be a variable, the message-elements could not
+                         * yet be created and the whole sequence might be broken. If this is
+                         * to be changed, createSequenceLParam and createSequenceWParam need
+                         * to be addepted, too.
+                         * traverses the messages from the current position forward till a
+                         * message with the correct type is found
                          */
+                }
+                return msgsGenerated;
+        }
+        private boolean createSequenceWParam(
+                        List<WindowsMessage> generatedMessageSeq, boolean msgsGenerated,
+                        int constMsgType, Element termElement)
+                        throws NoSuchElementException {
+                Iterator<WindowsMessage> seqIterator = generatedMessageSeq.iterator();
+                if (termElement.getName().equals("seqValue")) {
+                        String obj = termElement.getAttributeValue("seqObj");
+                        List<WindowsMessage> seqVar = getStoredSeqVariable(obj);
+                        if (msgsGenerated && seqVar.size() != generatedMessageSeq.size()) {
+                                throw new InvalidParameterException(
+                                                "Failure generating replay sequence for rule "
+                                                                + currentRuleName
+                                                                + ": One or more of the sequence variables used to generate a sequence have different lenghts.");
+                        }
+                        for (WindowsMessage msg : seqVar) {
+                                WindowsMessage currentSeqMsg = getCurrentSeqMsg(
+                                                generatedMessageSeq, msgsGenerated, constMsgType,
+                                                seqIterator);
+                                String paramValueStr = msg.getParameter(termElement
+                                                .getAttributeValue("param"));
+                                int paramValue = 0;
+                                try {
+                                        paramValue = Integer.parseInt(paramValueStr);
+                                        currentSeqMsg.setWPARAM(paramValue);
+                                } catch (NumberFormatException e) {
+                                        currentSeqMsg.setWPARAMasWindowDesc(paramValueStr);
+                                }
+                        }
+                        if (seqIterator.hasNext()) {
+                                // the first seq-var has a different number of elements than the
+                                // current one
+                                throw new NoSuchElementException();
+                        }
+                        msgsGenerated = true;
+                } else { // const value
+                        int paramValue = Integer.parseInt(getTermValue(null, termElement));
+                        while (seqIterator.hasNext()) {
+                                seqIterator.next().setWPARAM(paramValue);
+                        }
+                }
+                return msgsGenerated;
+        }
+                        currentMessage = sequenceIterator.next();
+                        if (type == currentMessage.getType()) {
+                                // message with the correct type found
+                                // eval child nodes for further matching/storing
+                                isMatch = evalEqualRestrictions(currentMessage, messageElement);
+                                // in case the message is a match, eval storage children
+                                if (isMatch) {
+                                        handleStorage(messageElement, currentMessage);
+                                        currentToken.setTarget(currentMessage
+                                                        .getXmlWindowDescription());
+                                        currentToken
+                                                        .setTargetShort(currentMessage.getParentNames());
+                                }
+                        }
+                }
+                return isMatch;
+        }
+        /**
+         * <p>
+         * Handles msg-nodes where multiple is true, i.e., sequences. Requires
+         * knowledge about the next msg-node to determine the end of the sequence.
+         * </p>
+         *
+         * @param messageElement
+         *            {@link Element} representing the msg-node
+         * @param nextMessageElement
+         *            {@link Element} representing the next msg-node; {@code null}
+         *            if the current node is the last one
+         * @return true, if a sequence is matched; false otherwise
+         */
+        private boolean matchMultipleMessages(Element messageElement,
+                        Element nextMessageElement) {
+                boolean isMatch = false;
+                boolean isCurrentMatch = false;
+                boolean nextMatchFound = false;
+                WindowsMessage currentMessage = null;
+                WindowsMessage nextMessage = null;
+                int type = Integer.parseInt(messageElement.getAttributeValue("type"));
+                int nextType = -1;
+                if (nextMessageElement != null) {
+                        nextType = Integer.parseInt(nextMessageElement
+                                        .getAttributeValue("type"));
+                }
+                while (!nextMatchFound && sequenceIterator.hasNext()) {
+                        currentMessage = sequenceIterator.next();
+                        if (type == currentMessage.getType()) {
+                                isCurrentMatch = evalEqualRestrictions(currentMessage,
+                                                messageElement);
+                                isMatch = isMatch || isCurrentMatch;
+                                if (isCurrentMatch) {
+                                        handleStorage(messageElement, currentMessage);
+                                        currentToken.setTarget(currentMessage
+                                                        .getXmlWindowDescription());
+                                        currentToken
+                                                        .setTargetShort(currentMessage.getParentNames());
+                                }
+                        }
+                        if (nextMessageElement != null && isMatch) {
+                                // peek next message to check if the sequence ends and the next
+                                // match is found
+                                if (!sequenceIterator.hasNext()) {
+                                        return false; // sequence is over, but not all messages are
+                                                                        // found
+                                }
+                                nextMessage = sequenceIterator.next();
+                                sequenceIterator.previous();
+                                if (nextType == nextMessage.getType()) {
+                                        nextMatchFound = evalEqualRestrictions(nextMessage,
+                                                        nextMessageElement);
+                                }
+                        }
+                }
+                return isMatch;
+        }
+        /**
+         * <p>
+         * Handles equals-nodes.
+         * </p>
+         *
+         * @param currentMessage
+         *            {@link Element} representing the msg-node the equals-node
+         *            belongs to
+         * @param messageElement
+         *            {@link Element} representing the equals-node to be evaluated
+         * @return true, if constraint is fulfilled; false otherwise
+         */
         @SuppressWarnings("unchecked")
         private boolean evalEqualRestrictions(WindowsMessage currentMessage,
 …
                                 "equalsSeq", rulesNamespace)) {
                         List<Element> termElements = childElement.getChildren();
+                        List<String> values1 = getTermValueSeq(currentMessage,
+                                        termElements.get(0));
+                        List<String> values2 = getTermValueSeq(currentMessage,
+                                        termElements.get(0));
+                        List<String> values1 = getTermValueSeq(termElements.get(0));
+                        List<String> values2 = getTermValueSeq(termElements.get(0));
                         if (values1 == null || values2 == null) {
                                 isMatch = false;
 …
+        }
+        /**
+         * <p>
+         * Handles store-nodes and storeSeq-nodes.
+         * </p>
+         *
+         * @param messageElement
+         *            {@link Element} representing the msg-node that is currently
+         *            being evaluated
+         * @param currentMessage
+         *            current message in the message sequence that is matched; this
+         *            is the message that is stored
+         */
+        @SuppressWarnings("unchecked")
+        private void handleStorage(Element messageElement,
+                        WindowsMessage currentMessage) {
+                for (Element childElement : (List<Element>) messageElement.getChildren(
+                                "store", rulesNamespace)) {
+                        String identifier = childElement.getAttributeValue("var");
+                        messageStorage.put(identifier, currentMessage);
+                        resolveHwnd(currentMessage, childElement);
+                }
+                for (Element childElement : (List<Element>) messageElement.getChildren(
+                                "storeSeq", rulesNamespace)) {
+                        String identifier = childElement.getAttributeValue("varSeq");
+                        Object tmp = messageStorage.get(identifier);
+                        List<WindowsMessage> storedSequence;
+                        if (tmp == null || tmp instanceof WindowsMessage) {
+                                storedSequence = new LinkedList<WindowsMessage>();
+                                storedSequence.add(currentMessage);
+                                messageStorage.put(identifier, storedSequence);
+                        } else if (tmp instanceof List<?>) {
+                                storedSequence = (List<WindowsMessage>) tmp;
+                                storedSequence.add(currentMessage);
+                                messageStorage.put(identifier, storedSequence);
+                        }
+                        resolveHwnd(currentMessage, childElement);
+                }
+        }
+        /**
+         * <p>
+         * Resolves a parameter that contains a HWND of a message to the target
+         * string of the HWND and stores it.
+         * </p>
+         *
+         * @param currentMessage
+         *            message whose HWND is resolved
+         * @param childElement
+         *            child element of the store node that represents the resolve
+         */
+        @SuppressWarnings("unchecked")
+        private void resolveHwnd(WindowsMessage currentMessage, Element childElement) {
+                List<Element> resolveElements = childElement.getChildren("resolveHwnd",
+                                rulesNamespace);
+                for (Element resolveElement : resolveElements) {
+                        String param = resolveElement.getAttributeValue("param");
+                        String storeParam = resolveElement.getAttributeValue("storeParam");
+                        int paramHwnd = Integer
+                                        .parseInt(currentMessage.getParameter(param));
+                        WindowTreeNode node = WindowTree.getInstance().find(paramHwnd);
+                        if (node != null) {
+                                currentMessage.addParameter(storeParam,
+                                                node.xmlRepresentation());
+                        }
+                }
+        }
+        // /////////////////////////////////////////////////////
+        // Helper functions for generating the replay, i.e.,
+        // parsing of genMsg und genMsgSeq-nodes
+        // /////////////////////////////////////////////////////
+        /**
+         * <p>
+         * Handles genMsg-nodes and adds the replay to the {@link Event} that is
+         * generated.
+         * </p>
+         *
+         * @param genMsgElement
+         *            {@link Element} representing the genMsg-node
+         */
         @SuppressWarnings("unchecked")
         private void generateReplayMessage(Element genMsgElement) {
 …
                                         String paramValueStr = getTermValue(null, termElement);
                                         long paramValue = 0;
+                                        Element loword = genMsgChild.getChild("LOWORD", rulesNamespace);
+                                        if( loword!=null ) {
+                                        Element loword = genMsgChild.getChild("LOWORD",
+                                                        rulesNamespace);
+                                        if (loword != null) {
                                                 paramValue = loHiWord(genMsgChild);
                                                 generatedMessage.setLPARAM(paramValue);
 …
                                                         generatedMessage.setLPARAM(paramValue);
                                                 } catch (NumberFormatException e) {
+                                                        generatedMessage.setLPARAMasWindowDesc(paramValueStr);
+                                                        generatedMessage
+                                                                        .setLPARAMasWindowDesc(paramValueStr);
+                                                }
+                                        }
 …
                                         String paramValueStr = getTermValue(null, termElement);
                                         long paramValue = 0;
+                                        Element loword = genMsgChild.getChild("LOWORD", rulesNamespace);
+                                        if( loword!=null ) {
+                                        Element loword = genMsgChild.getChild("LOWORD",
+                                                        rulesNamespace);
+                                        if (loword != null) {
                                                 paramValue = loHiWord(genMsgChild);
                                                 generatedMessage.setWPARAM(paramValue);
 …
                                                         generatedMessage.setWPARAM(paramValue);
                                                 } catch (NumberFormatException e) {
+                                                        generatedMessage.setWPARAMasWindowDesc(paramValueStr);
+                                                        generatedMessage
+                                                                        .setWPARAMasWindowDesc(paramValueStr);
+                                                }
+                                        }
 …
+        }
+        /**
+         * Handles genMsgSeq-nodes and adds the replay to the {@link Event} that is
+         * generated.</p>
+         *
+         * @param genMsgElement
+         *            {@link Element} representing the genMsgSeq-node.
+         */
         @SuppressWarnings("unchecked")
         private void generateReplaySequence(Element genMsgElement) {
 …
+        }
+        /**
+         * <p>
+         * Creates the targets for replay sequences generated with genMsgSeq-nodes.
+         * </p>
+         *
+         * @param generatedMessageSeq
+         *            list of the messages that is being generated
+         * @param msgsGenerated
+         *            boolean stating if the list of messages is already generated
+         *            or if the generation has to be handles by this method
+         * @param constMsgType
+         *            a constant message type that is used for message generation,
+         *            in case the list of message is generated by this method
+         * @param termElement
+         *            {@link Element} representing the term-node describing the
+         *            target
+         * @return true, if the list of message is generated after calling this
+         *         method; false otherwise
+         * @throws NoSuchElementException
+         *             thrown if the seqVar referred to in the termElement contains
+         *             a different number of messages than is contained in
+         *             messageSeq
+         */
+        private boolean createSequenceTarget(
+                        List<WindowsMessage> generatedMessageSeq, boolean msgsGenerated,
+                        int constMsgType, Element termElement)
+                        throws NoSuchElementException {
+                Iterator<WindowsMessage> seqIterator = generatedMessageSeq.iterator();
+                if (termElement.getName().equals("seqValue")) {
+                        String obj = termElement.getAttributeValue("seqObj");
+                        List<WindowsMessage> seqVar = getStoredSeqVariable(obj);
+                        if (msgsGenerated && seqVar.size() != generatedMessageSeq.size()) {
+                                throw new InvalidParameterException(
+                                                "Failure generating replay sequence for rule "
+                                                                + currentRuleName
+                                                                + ": One or more of the sequence variables used to generate a sequence have different lenghts.");
+                        }
+                        for (WindowsMessage msg : seqVar) {
+                                WindowsMessage currentSeqMsg = getCurrentSeqMsg(
+                                                generatedMessageSeq, msgsGenerated, constMsgType,
+                                                seqIterator);
+                                String targetString = msg.getParameter(termElement
+                                                .getAttributeValue("param"));
+                                currentSeqMsg.setXmlWindowDescription(targetString);
+                        }
+                        msgsGenerated = true;
+                } else { // const value
+                        throw new AssertionError("target must be a sequence variable!");
+                        /*
+                         * If target would not be a variable, the message-elements could not
+                         * yet be created and the whole sequence might be broken. If this is
+                         * to be changed, createSequenceLParam and createSequenceWParam need
+                         * to be addepted, too.
+                         */
+                }
+                return msgsGenerated;
+        }
+        /**
+         * <p>
+         * Creates the LPARAMs for replay sequences generated with genMsgSeq-nodes.
+         * </p>
+         *
+         * @param generatedMessageSeq
+         *            list of the messages that is being generated
+         * @param msgsGenerated
+         *            boolean stating if the list of messages is already generated
+         *            or if the generation has to be handles by this method
+         * @param constMsgType
+         *            a constant message type that is used for message generation,
+         *            in case the list of message is generated by this method
+         * @param termElement
+         *            {@link Element} representing the term-node describing the
+         *            LPARAM
+         * @return true, if the list of message is generated after calling this
+         *         method; false otherwise
+         * @throws NoSuchElementException
+         *             thrown if the seqVar referred to in the termElement contains
+         *             a different number of messages than is contained in
+         *             messageSeq
+         */
+        private boolean createSequenceLParam(
+                        List<WindowsMessage> generatedMessageSeq, boolean msgsGenerated,
+                        int constMsgType, Element termElement)
+                        throws NoSuchElementException {
+                Iterator<WindowsMessage> seqIterator = generatedMessageSeq.iterator();
+                if (termElement.getName().equals("seqValue")) {
+                        String obj = termElement.getAttributeValue("seqObj");
+                        List<WindowsMessage> seqVar = getStoredSeqVariable(obj);
+                        if (msgsGenerated && seqVar.size() != generatedMessageSeq.size()) {
+                                throw new InvalidParameterException(
+                                                "Failure generating replay sequence for rule "
+                                                                + currentRuleName
+                                                                + ": One or more of the sequence variables used to generate a sequence have different lenghts.");
+                        }
+                        for (WindowsMessage msg : seqVar) {
+                                WindowsMessage currentSeqMsg = getCurrentSeqMsg(
+                                                generatedMessageSeq, msgsGenerated, constMsgType,
+                                                seqIterator);
+                                String paramValueStr = msg.getParameter(termElement
+                                                .getAttributeValue("param"));
+                                int paramValue = 0;
+                                try {
+                                        paramValue = Integer.parseInt(paramValueStr);
+                                        currentSeqMsg.setLPARAM(paramValue);
+                                } catch (NumberFormatException e) {
+                                        currentSeqMsg.setLPARAMasWindowDesc(paramValueStr);
+                                }
+                        }
+                        if (seqIterator.hasNext()) {
+                                // the first seq-var has a different number of elements than the
+                                // current one
+                                throw new NoSuchElementException();
+                        }
+                        msgsGenerated = true;
+                } else { // const value
+                        int paramValue = Integer.parseInt(getTermValue(null, termElement));
+                        while (seqIterator.hasNext()) {
+                                seqIterator.next().setLPARAM(paramValue);
+                        }
+                }
+                return msgsGenerated;
+        }
+        /**
+         * <p>
+         * Creates the WPARAMs for replay sequences generated with genMsgSeq-nodes.
+         * </p>
+         *
+         * @param generatedMessageSeq
+         *            list of the messages that is being generated
+         * @param msgsGenerated
+         *            boolean stating if the list of messages is already generated
+         *            or if the generation has to be handles by this method
+         * @param constMsgType
+         *            a constant message type that is used for message generation,
+         *            in case the list of message is generated by this method
+         * @param termElement
+         *            {@link Element} representing the term-node describing the
+         *            WPARAM
+         * @return true, if the list of message is generated after calling this
+         *         method; false otherwise
+         * @throws NoSuchElementException
+         *             thrown if the seqVar referred to in the termElement contains
+         *             a different number of messages than is contained in
+         *             messageSeq
+         */
+        private boolean createSequenceWParam(
+                        List<WindowsMessage> generatedMessageSeq, boolean msgsGenerated,
+                        int constMsgType, Element termElement)
+                        throws NoSuchElementException {
+                Iterator<WindowsMessage> seqIterator = generatedMessageSeq.iterator();
+                if (termElement.getName().equals("seqValue")) {
+                        String obj = termElement.getAttributeValue("seqObj");
+                        List<WindowsMessage> seqVar = getStoredSeqVariable(obj);
+                        if (msgsGenerated && seqVar.size() != generatedMessageSeq.size()) {
+                                throw new InvalidParameterException(
+                                                "Failure generating replay sequence for rule "
+                                                                + currentRuleName
+                                                                + ": One or more of the sequence variables used to generate a sequence have different lenghts.");
+                        }
+                        for (WindowsMessage msg : seqVar) {
+                                WindowsMessage currentSeqMsg = getCurrentSeqMsg(
+                                                generatedMessageSeq, msgsGenerated, constMsgType,
+                                                seqIterator);
+                                String paramValueStr = msg.getParameter(termElement
+                                                .getAttributeValue("param"));
+                                int paramValue = 0;
+                                try {
+                                        paramValue = Integer.parseInt(paramValueStr);
+                                        currentSeqMsg.setWPARAM(paramValue);
+                                } catch (NumberFormatException e) {
+                                        currentSeqMsg.setWPARAMasWindowDesc(paramValueStr);
+                                }
+                        }
+                        if (seqIterator.hasNext()) {
+                                // the first seq-var has a different number of elements than the
+                                // current one
+                                throw new NoSuchElementException();
+                        }
+                        msgsGenerated = true;
+                } else { // const value
+                        int paramValue = Integer.parseInt(getTermValue(null, termElement));
+                        while (seqIterator.hasNext()) {
+                                seqIterator.next().setWPARAM(paramValue);
+                        }
+                }
+                return msgsGenerated;
+        }
+        /**
+         * <p>
+         * If a message sequence is already generated, i.e., msgsGenerated is true,
+         * the seqIterator is used to iterate through these messages and return the
+         * current one. If the message sequence is not yet generated, i.e.,
+         * msgsGenerated is false, the message sequence is generated on the fly
+         * during each call of this message and the newly generated messages are
+         * returned.
+         * </p>
+         *
+         * @param generatedMessageSeq
+         *            message sequence
+         * @param msgsGenerated
+         *            indicates if generatedMessageSeq is already generated or has
+         *            to be generated on the fly by this method
+         * @param constMsgType
+         *            type of the message to be used for message generation
+         * @param seqIterator
+         *            iterates through an already generated message sequence; must
+         *            not be {@code null}, if msgsGenerated is true
+         * @return current message
+         */
         private WindowsMessage getCurrentSeqMsg(
                         List<WindowsMessage> generatedMessageSeq, boolean msgsGenerated,
 …
+        }
+        // ////////////////////////////
+        // General helper functions //
+        // ////////////////////////////
+        /**
+         * <p>
+         * Retrieves a message from the storage for, e.g., comparison or replay.
+         * "this" is used to refer to the current message.
+         * </p>
+         *
+         * @param currentMessage
+         *            current message during the parsing; passed to handle "this"
+         * @param obj
+         *            object identifier in the storage
+         * @return message retrieved from the storage
+         * @throws InvalidParameterException
+         *             thrown in case of invalid uses of "this" or if no message
+         *             with the identifier obj is found in the storage
+         */
         private WindowsMessage getStoredMessageVariable(
                         WindowsMessage currentMessage, String obj)
 …
+        }
+        /**
+         * <p>
+         * Retrieves a stored message sequence from the storage.
+         * </p>
+         *
+         * @param obj
+         *            object identifier in the storage
+         * @return message sequence retrieved from the storage
+         * @throws InvalidParameterException
+         *             thrown if no message sequences with the identifier obj is
+         *             found in the storage
+         */
         @SuppressWarnings("unchecked")
         private List<WindowsMessage> getStoredSeqVariable(String obj)
 …
+        }
+        /**
+         * <p>
+         * Handles term-nodes and returns the value of the described term.
+         * </p>
+         *
+         * @param currentMessage
+         *            current message during the parsing; required to resolve
+         *            references to "this" in a term
+         * @param termElement
+         *            {@link Element} representing the term node
+         * @return value of the term or {@code null} of the term node could not be
+         *         evaluated
+         */
         private String getTermValue(WindowsMessage currentMessage,
                         Element termElement) {
 …
                                         String target = varMessage.getXmlWindowDescription();
                                         int index = target.lastIndexOf("<");
                                         if( index==0 ) {
+                                        if (index == 0) {
                                                 Console.println("Trying to adress parent of top-level window! Replay probably invalid!");
+                                        }
 …
+        }
+        private List<String> getTermValueSeq(WindowsMessage currentMessage,
+                        Element termElement) {
+        /**
+         * <p>
+         * Handles term-nodes contained by equalSeq nodes.
+         * </p>
+         *
+         * @param termElement
+         *            {@link Element} representing the term-node
+         * @return list of values of the term
+         */
+        private List<String> getTermValueSeq(Element termElement) {
                 List<String> values = new LinkedList<String>();
                 if (termElement.getName().equals("seqValue")) {
 …
+        }
+        @SuppressWarnings("unchecked")
+        private void handleStorage(Element messageElement,
+                        WindowsMessage currentMessage) {
+                for (Element childElement : (List<Element>) messageElement.getChildren(
+                                "store", rulesNamespace)) {
+                        String identifier = childElement.getAttributeValue("var");
+                        messageStorage.put(identifier, currentMessage);
+                        resolveHwnd(currentMessage, childElement);
+                }
+                for (Element childElement : (List<Element>) messageElement.getChildren(
+                                "storeSeq", rulesNamespace)) {
+                        String identifier = childElement.getAttributeValue("varSeq");
+                        Object tmp = messageStorage.get(identifier);
+                        List<WindowsMessage> storedSequence;
+                        if (tmp == null || tmp instanceof WindowsMessage) {
+                                storedSequence = new LinkedList<WindowsMessage>();
+                                storedSequence.add(currentMessage);
+                                messageStorage.put(identifier, storedSequence);
+                        } else if (tmp instanceof List<?>) {
+                                storedSequence = (List<WindowsMessage>) tmp;
+                                storedSequence.add(currentMessage);
+                                messageStorage.put(identifier, storedSequence);
+                        }
+                        resolveHwnd(currentMessage, childElement);
+                }
+        }
+        private boolean matchMultipleMessages(Element messageElement,
+                        Element nextMessageElement) {
+                boolean isMatch = false;
+                boolean isCurrentMatch = false;
+                boolean nextMatchFound = false;
+                WindowsMessage currentMessage = null;
+                WindowsMessage nextMessage = null;
+                int type = Integer.parseInt(messageElement.getAttributeValue("type"));
+                int nextType = -1;
+                if (nextMessageElement != null) {
+                        nextType = Integer.parseInt(nextMessageElement
+                                        .getAttributeValue("type"));
+                }
+                while (!nextMatchFound && sequenceIterator.hasNext()) {
+                        currentMessage = sequenceIterator.next();
+                        if (type == currentMessage.getType()) {
+                                isCurrentMatch = evalEqualRestrictions(currentMessage,
+                                                messageElement);
+                                isMatch = isMatch || isCurrentMatch;
+                                if (isCurrentMatch) {
+                                        handleStorage(messageElement, currentMessage);
+                                        currentToken.setTarget(currentMessage
+                                                        .getXmlWindowDescription());
+                                        currentToken
+                                                        .setTargetShort(currentMessage.getParentNames());
+                                }
+                        }
+                        if (nextMessageElement != null && isMatch) {
+                                // peek next message to check if the sequence ends and the next
+                                // match is found
+                                if (!sequenceIterator.hasNext()) {
+                                        return false; // sequence is over, but not all messages are
+                                                                        // found
+                                }
+                                nextMessage = sequenceIterator.next();
+                                sequenceIterator.previous();
+                                if (nextType == nextMessage.getType()) {
+                                        nextMatchFound = evalEqualRestrictions(nextMessage,
+                                                        nextMessageElement);
+                                }
+                        }
+                }
+                return isMatch;
+        }
+        private boolean matchSingleMessage(Element messageElement) {
+                boolean isMatch = false;
+                WindowsMessage currentMessage = null;
+                int type = Integer.parseInt(messageElement.getAttributeValue("type"));
+                while (!isMatch && sequenceIterator.hasNext()) {
+                        // traverses the messages from the current position forward till a
+                        // message with the correct type is found
+                        currentMessage = sequenceIterator.next();
+                        if (type == currentMessage.getType()) {
+                                // message with the correct type found
+                                // eval child nodes for further matching/storing
+                                isMatch = evalEqualRestrictions(currentMessage, messageElement);
+                                // in case the message is a match, eval storage children
+                                if (isMatch) {
+                                        handleStorage(messageElement, currentMessage);
+                                        currentToken.setTarget(currentMessage
+                                                        .getXmlWindowDescription());
+                                        currentToken
+                                                        .setTargetShort(currentMessage.getParentNames());
+                                }
+                        }
+                }
+                return isMatch;
+        }
+        @SuppressWarnings("unchecked")
+        private void resolveHwnd(WindowsMessage currentMessage, Element childElement) {
+                List<Element> resolveElements = childElement.getChildren("resolveHwnd",
+                                rulesNamespace);
+                for (Element resolveElement : resolveElements) {
+                        String param = resolveElement.getAttributeValue("param");
+                        String storeParam = resolveElement.getAttributeValue("storeParam");
+                        int paramHwnd = Integer
+                                        .parseInt(currentMessage.getParameter(param));
+                        WindowTreeNode node = WindowTree.getInstance().find(paramHwnd);
+                        if (node != null) {
+                                currentMessage.addParameter(storeParam,
+                                                node.xmlRepresentation());
+                        }
+                }
+        }
+        /**
+         * <p>
+         * Handles LOWORD and HIWORD child nodes of LPARAM and WPARAM nodes. The
+         * returned value is the LPARAM/WPARAM value based on the LOWORD and HIWORD.
+         * </p>
+         *
+         * @param param
+         *            {@link Element} representing the LPARAM/WPARAM node
+         * @return value of the LPARAM/WPARAM
+         */
         private long loHiWord(Element param) {
                 Element loword = param.getChild("LOWORD", rulesNamespace);
                 Element hiword = param.getChild("HIWORD", rulesNamespace);
+                String lowordStr = getTermValue(null, (Element) loword.getChildren().get(0));
+                String hiwordStr = getTermValue(null, (Element) hiword.getChildren().get(0));
+                return MAKEPARAM(Short.parseShort(lowordStr), Short.parseShort(hiwordStr));
+        }
+                String lowordStr = getTermValue(null, (Element) loword.getChildren()
+                                .get(0));
+                String hiwordStr = getTermValue(null, (Element) hiword.getChildren()
+                                .get(0));
+                return MAKEPARAM(Short.parseShort(lowordStr),
+                                Short.parseShort(hiwordStr));
+        }
+        /**
+         * <p>
+         * Takes to short integers and combines them into the high and low order
+         * bits of an integer.
+         * </p>
+         *
+         * @param loword
+         *            low word
+         * @param hiword
+         *            high word
+         * @return combined integer
+         */
         private static int MAKEPARAM(short loword, short hiword) {
                 return loword| ((int) hiword) << Short.SIZE;
+                return loword | ((int) hiword) << Short.SIZE;
+        }

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/HandlerCreate.java

-                      r156
+                      r171
 import de.ugoe.cs.eventbench.windows.data.WindowTree;
+/**
+ * <p>
+ * Message handler for {@code WM_CREATE} messages. The handler maintains the
+ * {@link WindowTree}.
+ * </p>
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
 public class HandlerCreate extends MessageHandler {
+        /**
+         * <p>
+         * Constructor. Creates a new HandlerCreate.
+         * </p>
+         */
         public HandlerCreate() {
                 super();
+        }
+        /**
+         * <p>
+         * Name of the created window.
+         * </p>
+         */
         private String windowName;
+        /**
+         * <p>
+         * HWND of the created window.
+         * </p>
+         */
         private int hwnd;
+        /**
+         * <p>
+         * HWND of the created window's parent.
+         * </p>
+         */
         private int parentHwnd;
+        /**
+         * <p>
+         * Resource Id of the created window.
+         * </p>
+         */
         private int resourceId;
+        /**
+         * <p>
+         * Window class of the created window.
+         * </p>
+         */
         private String className;
+        /**
+         * <p>
+         * Modality of the created window.
+         * </p>
+         */
         private boolean isModal;
+        /*
+         * (non-Javadoc)
+         *
+         * @see de.ugoe.cs.eventbench.windows.MessageHandler#onEndElement()
+         */
         @Override
         public void onEndElement() {
+                if( hwnd!=0 ) {
+                        WindowTree.getInstance().add(parentHwnd, hwnd, windowName, resourceId, className, isModal);
+                if (hwnd != 0) {
+                        WindowTree.getInstance().add(parentHwnd, hwnd, windowName,
+                                        resourceId, className, isModal);
+                }
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * de.ugoe.cs.eventbench.windows.MessageHandler#onParameter(java.lang.String
+         * , java.lang.String)
+         */
         @Override
         public void onParameter(String name, String value) {
                 if( name.equals("window.hwnd") ) {
+                if (name.equals("window.hwnd")) {
                         hwnd = Integer.parseInt(value);
+                }
+                else if( name.equals("window.name") ) {
+                } else if (name.equals("window.name")) {
                         windowName = value;
+                }
+                else if( name.equals("window.parent.hwnd") ) {
+                } else if (name.equals("window.parent.hwnd")) {
                         parentHwnd = Integer.parseInt(value);
+                }
+                else if( name.equals("window.resourceId") ) {
+                } else if (name.equals("window.resourceId")) {
                         resourceId = Integer.parseInt(value);
+                }
+                else if( name.equals("window.class") ) {
+                        if( value.startsWith("Afx:") ) {
+                } else if (name.equals("window.class")) {
+                        if (value.startsWith("Afx:")) {
                                 className = "Afx:";
                         } else {
                                 className = value;
+                        }
+                }
+                else if( name.equals("window.ismodal") ) {
+                        if( value.equals("true") || value.equals("1") ) {
+                } else if (name.equals("window.ismodal")) {
+                        if (value.equals("true") || value.equals("1")) {
                                 isModal = true;
+                        }
 …
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see de.ugoe.cs.eventbench.windows.MessageHandler#onStartElement()
+         */
         @Override
         public void onStartElement() {

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/HandlerDestroy.java

-                      r75
+                      r171
 import de.ugoe.cs.eventbench.windows.data.WindowTree;
+/**
+ * <p>
+ * Handler for {@code WM_DESTROY} message. The handler maintains the
+ * {@link WindowTree}.
+ * </p>
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
 public class HandlerDestroy extends MessageHandler {
+        /**
+         * <p>
+         * Constructor. Creates a new HandlerDestroy.
+         * </p>
+         */
         public HandlerDestroy() {
                 super();
+        }
+        /**
+         * <p>
+         * HWND of the window that is destroyed.
+         * </p>
+         */
         private int hwnd;
+        /*
+         * (non-Javadoc)
+         *
+         * @see de.ugoe.cs.eventbench.windows.MessageHandler#onEndElement()
+         */
         @Override
         public void onEndElement() {
                 if( hwnd!=0 ) {
+                if (hwnd != 0) {
                         WindowTree.getInstance().remove(hwnd);
+                }
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * de.ugoe.cs.eventbench.windows.MessageHandler#onParameter(java.lang.String
+         * , java.lang.String)
+         */
         @Override
         public void onParameter(String name, String value) {
                 if( name.equals("window.hwnd") ) {
+                if (name.equals("window.hwnd")) {
                         hwnd = Integer.parseInt(value);
+                }
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see de.ugoe.cs.eventbench.windows.MessageHandler#onStartElement()
+         */
         @Override
         public void onStartElement() {

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/HandlerSetText.java

-                      r75
+                      r171
 import de.ugoe.cs.eventbench.windows.data.WindowTreeNode;
+/**
+ * <p>
+ * Handles {@code WM_SETTEXT} messages. Handler maintains the {@link WindowTree}.
+ * </p>
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
 public class HandlerSetText extends MessageHandler {
+        /**
+         * <p>
+         * Constructor. Creates a new HanderSetText.
+         * </p>
+         */
         public HandlerSetText() {
                 super();
+        }
+        /**
+         * <p>
+         * New name of the window.
+         * </p>
+         */
         private String windowName;
+        /**
+         * <p>
+         * HWND of the window.
+         * </p>
+         */
         private int hwnd;
+        /*
+         * (non-Javadoc)
+         *
+         * @see de.ugoe.cs.eventbench.windows.MessageHandler#onEndElement()
+         */
         @Override
         public void onEndElement() {
 …
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * de.ugoe.cs.eventbench.windows.MessageHandler#onParameter(java.lang.String
+         * , java.lang.String)
+         */
         @Override
         public void onParameter(String name, String value) {
 …
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see de.ugoe.cs.eventbench.windows.MessageHandler#onStartElement()
+         */
         @Override
         public void onStartElement() {

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/LogParser.java

-                      r77
+                      r171
 import de.ugoe.cs.util.console.Console;
+/**
+ * <p>
+ * This class provides functionality to parse XML log files generated by the
+ * MFCUsageMonitor of EventBench. The result of parsing a file is a collection
+ * of event sequences. It uses the {@link SequenceSplitter} and the
+ * {@link EventGenerator} as well as custom defined {@link MessageHandler} for
+ * the parsing.
+ * </p>
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
 public class LogParser extends DefaultHandler {
+        /**
+         * <p>
+         * If a custom message handler is used, this field contains its handle.
+         * Otherwise this field is {@code null}.
+         * </p>
+         */
         private MessageHandler currentHandler;
+        /**
+         * <p>
+         * Handle to the message that is currently parsed.
+         * </p>
+         */
         private WindowsMessage currentMessage;
+        /**
+         * <p>
+         * {@link SequenceSplitter} instance used by the {@link LogParser}.
+         * </p>
+         */
         private SequenceSplitter sequenceSplitter;
+        /**
+         * <p>
+         * Collection of event sequences that is contained in the log file, which is
+         * parsed.
+         * </p>
+         */
         private List<List<WindowsEvent>> sequences;
+        /**
+         * <p>
+         * Debugging variable that allows the analysis which message type occurs how
+         * often in the log file. Can be used to enhance the message filter.
+         * </p>
+         */
         private SortedMap<Integer, Integer> typeCounter;
+        /**
+         * <p>
+         * Debugging variable that enables the counting of the occurrences of each
+         * message. Used in combination with {@link #typeCounter}.
+         * </p>
+         */
         private boolean countMessageOccurences;
+        /**
+         * <p>
+         * Constructor. Creates a new LogParser that does not count message
+         * occurrences.
+         * </p>
+         */
         public LogParser() {
                 this(false);
+        }
+        /**
+         * <p>
+         * Constructor. Creates a new LogParser.
+         * </p>
+         *
+         * @param countMessageOccurences
+         *            if true, the occurrences of each message type in the log is
+         *            counted.
+         */
         public LogParser(boolean countMessageOccurences) {
                 sequenceSplitter = new SequenceSplitter();
 …
                 currentHandler = null;
                 this.countMessageOccurences = countMessageOccurences;
                 if( countMessageOccurences) {
+                if (countMessageOccurences) {
                         typeCounter = new TreeMap<Integer, Integer>();
+                }
+        }
+        }
+        /**
+         * <p>
+         * Returns the collection of event sequences that is obtained from parsing
+         * log files.
+         * </p>
+         *
+         * @return collection of event sequences
+         */
         public List<List<WindowsEvent>> getSequences() {
                 return sequences;
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see org.xml.sax.helpers.DefaultHandler#startElement(java.lang.String,
+         * java.lang.String, java.lang.String, org.xml.sax.Attributes)
+         */
         @Override
+        public void startElement(String uri, String localName, String qName, Attributes atts) throws SAXException {
+                if( qName.equals("session") ) {
+        public void startElement(String uri, String localName, String qName,
+                        Attributes atts) throws SAXException {
+                if (qName.equals("session")) {
                         Console.traceln("start of session");
                         sequenceSplitter = new SequenceSplitter();
+                }
+                else if( qName.equals("msg") ) {
+                } else if (qName.equals("msg")) {
                         String msgType = atts.getValue("type");
                         int msgInt = -1;
                         try {
                                 msgInt = Integer.parseInt(msgType);
                                 if( countMessageOccurences ) {
+                                if (countMessageOccurences) {
                                         Integer currentCount = typeCounter.get(msgInt);
                                         if( currentCount==null ) {
+                                        if (currentCount == null) {
                                                 typeCounter.put(msgInt, 1);
                                         } else {
                                                 typeCounter.put(msgInt, currentCount+1);
+                                                typeCounter.put(msgInt, currentCount + 1);
+                                        }
+                                }
                                 if( msgInt==MessageDefs.WM_CREATE ) {
+                                if (msgInt == MessageDefs.WM_CREATE) {
                                         currentHandler = new HandlerCreate();
                                         currentHandler.onStartElement();
+                                }
+                                else if( msgInt==MessageDefs.WM_DESTROY ) {
+                                } else if (msgInt == MessageDefs.WM_DESTROY) {
                                         currentHandler = new HandlerDestroy();
                                         currentHandler.onStartElement();
+                                }
+                                else if( msgInt==MessageDefs.WM_SETTEXT ) {
+                                } else if (msgInt == MessageDefs.WM_SETTEXT) {
                                         currentHandler = new HandlerSetText();
                                         currentHandler.onStartElement();
 …
                                         currentMessage = new WindowsMessage(msgInt);
+                                }
                         } catch(NumberFormatException e) {
+                        } catch (NumberFormatException e) {
                                 Console.printerrln("Invalid message type: type not a number");
                                 e.printStackTrace();
+                        }
+                }
                 else if( qName.equals("param") ) {
                         if( currentHandler!=null ) {
                                 currentHandler.onParameter(atts.getValue("name"), atts.getValue("value"));
+                } else if (qName.equals("param")) {
+                        if (currentHandler != null) {
+                                currentHandler.onParameter(atts.getValue("name"),
+                                                atts.getValue("value"));
                         } else {
+                                currentMessage.addParameter(atts.getValue("name"), atts.getValue("value"));
+                        }
+                }
+        }
+                                currentMessage.addParameter(atts.getValue("name"),
+                                                atts.getValue("value"));
+                        }
+                }
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see org.xml.sax.helpers.DefaultHandler#endElement(java.lang.String,
+         * java.lang.String, java.lang.String)
+         */
         @Override
+        public void endElement(String uri, String localName, String qName) throws SAXException {
+                if( qName.equals("msg") ) {
+                        if( currentHandler!=null ) {
+        public void endElement(String uri, String localName, String qName)
+                        throws SAXException {
+                if (qName.equals("msg")) {
+                        if (currentHandler != null) {
                                 currentHandler.onEndElement();
                                 currentHandler = null;
 …
                                         sequenceSplitter.addMessage(currentMessage);
                                 } catch (InvalidParameterException e) {
                                         Console.traceln(e.getMessage() + " WindowsMessage " + currentMessage + " ignored.");
+                                }
+                        }
+                }
                 else if(qName.equals("session")) {
+                                        Console.traceln(e.getMessage() + " WindowsMessage "
+                                                        + currentMessage + " ignored.");
+                                }
+                        }
+                } else if (qName.equals("session")) {
                         sequenceSplitter.endSession();
                         sequences.add(sequenceSplitter.getSequence());
 …
+                }
+        }
+        /**
+         * <p>
+         * Parses a given log file and adds its contents to the collection of event
+         * sequences.
+         * </p>
+         *
+         * @param filename
+         *            name and path of the log file
+         */
         public void parseFile(String filename) {
                 if( filename==null ) {
+                if (filename == null) {
                         throw new InvalidParameterException("filename must not be null");
+                }
                 SAXParserFactory spf = SAXParserFactory.newInstance();
                 spf.setValidating(true);
                 SAXParser saxParser = null;
                 InputSource inputSource = null;
                 try {
                         saxParser = spf.newSAXParser();
+                        inputSource = new InputSource(new InputStreamReader(new FileInputStream(filename), "UTF-16"));
+                        inputSource = new InputSource(new InputStreamReader(
+                                        new FileInputStream(filename), "UTF-16"));
                 } catch (UnsupportedEncodingException e) {
                         e.printStackTrace();
 …
                         e.printStackTrace();
+                }
+                if( inputSource!=null ) {
+                inputSource.setSystemId("file://" + new File(filename).getAbsolutePath());
+                try {
+                        if( saxParser==null) {
+                                throw new RuntimeException("SAXParser creation failed");
+                        }
+                if (inputSource != null) {
+                        inputSource.setSystemId("file://"
+                                        + new File(filename).getAbsolutePath());
+                        try {
+                                if (saxParser == null) {
+                                        throw new RuntimeException("SAXParser creation failed");
+                                }
                                 saxParser.parse(inputSource, this);
+                } catch (SAXParseException e) {
+                        Console.printerrln("Failure parsing file in line " + e.getLineNumber() + ", column " + e.getColumnNumber() +".");
+                        e.printStackTrace();
+                        } catch (SAXParseException e) {
+                                Console.printerrln("Failure parsing file in line "
+                                                + e.getLineNumber() + ", column " + e.getColumnNumber()
+                                                + ".");
+                                e.printStackTrace();
                         } catch (SAXException e) {
                                 e.printStackTrace();
 …
+                        }
+                }
                 if( countMessageOccurences ) {
+                if (countMessageOccurences) {
                         Console.println("Message statistics:");
+                        Console.println(typeCounter.toString().replace(" ", StringTools.ENDLINE).replaceAll("[\\{\\}]",""));
+                        Console.println(typeCounter.toString()
+                                        .replace(" ", StringTools.ENDLINE)
+                                        .replaceAll("[\\{\\}]", ""));
+                }
+        }

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/LogPreprocessor.java

-                      r75
+                      r171
 import de.ugoe.cs.util.console.Console;
+/**
+ * <p>
+ * Pre-processes log files generated by the EventBench's MFCUsageMonitor. It
+ * decodes Base64 encoding into UTF-16. It removes all lines of the log file,
+ * that do not start with the prefix "UL:", end everything before the prefix and
+ * the prefix itself.
+ * </p>
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
 public class LogPreprocessor {
+        /**
+         * <p>
+         * Internal flag that monitors whether there is an open session-node in the
+         * XML file to ensure that there is a closing session-node for each opening
+         * session node and, thereby, ensure that the XML file is well formed.
+         * </p>
+         */
         private boolean sessionOpen = false;
+        /**
+         * <p>
+         * Internal flag that monitors whether a message node is longer than one
+         * line, as the prefix handling is different in this case.
+         * </p>
+         */
         private boolean msgIncomplete = false;
+        /**
+         * <p>
+         * Flag that marks whether the log file is Base64 encoded.
+         * </p>
+         */
         private boolean base64;
+        /**
+         * <p>
+         * Constructor. Creates a new LogPreprocessor that does not decode Base64.
+         * </p>
+         */
         public LogPreprocessor() {
                 this(false);
+        }
+        /**
+         * <p>
+         * Constructor. Creates a new LogPreprocessor.
+         * </p>
+         *
+         * @param base64
+         *            if true, Base64 will be decoded.
+         */
         public LogPreprocessor(boolean base64) {
                 this.base64 = base64;
+        }
+        public void convertToXml(String source, String target) throws IOException, FileNotFoundException {
+                OutputStreamWriter targetFile = new OutputStreamWriter(new FileOutputStream(target), "UTF-16");
+                targetFile.write("<?xml version=\"1.0\" encoding=\"UTF-16\"?>" + StringTools.ENDLINE);
+        /**
+         * <p>
+         * Pre-processes a single log file.
+         * </p>
+         *
+         * @param source
+         *            name and path of the source file
+         * @param target
+         *            name and path of the target file
+         * @throws IOException
+         *             thrown if there is a problem with reading from or writing to
+         *             the source, respectively target file
+         * @throws FileNotFoundException
+         *             thrown if the source file is not found
+         */
+        public void convertToXml(String source, String target) throws IOException,
+                        FileNotFoundException {
+                OutputStreamWriter targetFile = new OutputStreamWriter(
+                                new FileOutputStream(target), "UTF-16");
+                targetFile.write("<?xml version=\"1.0\" encoding=\"UTF-16\"?>"
+                                + StringTools.ENDLINE);
                 targetFile.write("<log>" + StringTools.ENDLINE);
                 processFile(source, targetFile);
                 if( sessionOpen ) {
+                if (sessionOpen) {
                         targetFile.write(" </session>" + StringTools.ENDLINE);
+                }
 …
                 targetFile.close();
+        }
+        public void convertDirToXml(String path, String target) throws IOException, FileNotFoundException {
+                OutputStreamWriter targetFile = new OutputStreamWriter(new FileOutputStream(target), "UTF-16");
+                targetFile.write("<?xml version=\"1.0\" encoding=\"UTF-16\"?>" + StringTools.ENDLINE);
+        /**
+         * <p>
+         * Pre-processes all files in a given source folder.
+         * </p>
+         *
+         * @param source
+         *            path of the source folder
+         * @param target
+         *            name and path of the target file
+         * @throws IOException
+         *             thrown if there is a problem with reading from or writing to
+         *             the source, respectively target file
+         * @throws FileNotFoundException
+         *             thrown if the source file is not found
+         */
+        public void convertDirToXml(String path, String target) throws IOException,
+                        FileNotFoundException {
+                OutputStreamWriter targetFile = new OutputStreamWriter(
+                                new FileOutputStream(target), "UTF-16");
+                targetFile.write("<?xml version=\"1.0\" encoding=\"UTF-16\"?>"
+                                + StringTools.ENDLINE);
                 targetFile.write("<log>" + StringTools.ENDLINE);
                 File folder = new File(path);
                 if( !folder.isDirectory() ) {
+                if (!folder.isDirectory()) {
                         throw new IOException(path + " is not a directory");
+                }
                 String absolutPath = folder.getAbsolutePath();
                 for( String filename : folder.list() ) {
+                for (String filename : folder.list()) {
                         String source = absolutPath + "/" + filename;
                         Console.traceln("Processing file: " + source);
                         processFile(source, targetFile);
+                }
                 if( sessionOpen ) {
+                if (sessionOpen) {
                         targetFile.write(" </session>" + StringTools.ENDLINE);
+                }
 …
+        }
+        /**
+         * <p>
+         * Internal function that pre-processes a log file.
+         * </p>
+         *
+         * @param source
+         *            name and path of the source file
+         * @param target
+         *            name and path of the target file
+         * @throws IOException
+         *             thrown if there is a problem with reading from or writing to
+         *             the source, respectively target file
+         * @throws FileNotFoundException
+         *             thrown if the source file is not found
+         */
         private void processFile(String source, OutputStreamWriter targetFile)
                         throws FileNotFoundException, IOException {
 …
                 String incompleteLine = "";
                 // Open source and read line by line
                 for( String currentLine : lines ) {
                         if( currentLine.contains("UL: <session>")) {
                                 if( sessionOpen) {
+                for (String currentLine : lines) {
+                        if (currentLine.contains("UL: <session>")) {
+                                if (sessionOpen) {
                                         targetFile.write(" </session>" + StringTools.ENDLINE);
                                         targetFile.write(" <session>" + StringTools.ENDLINE);
 …
                                         sessionOpen = true;
+                                }
                         } else if( currentLine.contains("UL: </session>")) {
                                 if( sessionOpen) {
+                        } else if (currentLine.contains("UL: </session>")) {
+                                if (sessionOpen) {
                                         targetFile.write(" </session>" + StringTools.ENDLINE);
                                         sessionOpen = false;
+                                }
                         } else if( msgIncomplete || currentLine.contains("UL: ")) {
+                        } else if (msgIncomplete || currentLine.contains("UL: ")) {
                                 String currentContent;
                                 String actualLine;
                                 if( msgIncomplete ) {
+                                if (msgIncomplete) {
                                         actualLine = currentLine;
                                 } else {
 …
                                         actualLine = splitResult[1];
+                                }
                                 if( base64 ) {
+                                if (base64) {
                                         Base64 decoder = new Base64();
                                         byte[] decoded = decoder.decode(actualLine);
                                         currentContent = new String(decoded, "UTF-16LE");
+                                        currentContent = currentContent.substring(0, currentContent.length()-1);
+                                        currentContent = currentContent.substring(0,
+                                                        currentContent.length() - 1);
                                 } else {
                                         currentContent = actualLine;
+                                }
                                 if( msgIncomplete ) {
+                                if (msgIncomplete) {
                                         incompleteLine += currentContent;
                                         if( incompleteLine.contains("</msg>") ) {
+                                        if (incompleteLine.contains("</msg>")) {
                                                 msgIncomplete = false;
                                                 targetFile.write(incompleteLine + StringTools.ENDLINE);
 …
+                                        }
                                 } else {
+                                        if( currentContent.contains("<msg") && sessionOpen ) {
+                                                if( currentContent.contains("</msg>") ) {
+                                                        targetFile.write("  " + currentContent + StringTools.ENDLINE);
+                                        if (currentContent.contains("<msg") && sessionOpen) {
+                                                if (currentContent.contains("</msg>")) {
+                                                        targetFile.write("  " + currentContent
+                                                                        + StringTools.ENDLINE);
                                                 } else {
                                                         msgIncomplete = true;

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/MFCReplayDecorator.java

-                      r98
+                      r171
 import de.ugoe.cs.util.StringTools;
+/**
+ * <p>
+ * {@link IReplayDecorator} for replay generated for EventBench's MFCReplay tool.
+ * </p>
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
 public class MFCReplayDecorator implements IReplayDecorator {
         /**
+         * <p>
          * Id for object serialization.
+         * </p>
          */
         private static final long serialVersionUID = 1L;
+        /**
+         * <p>
+         * The instance of the {@link MFCReplayDecorator} (implemented as
+         * singleton).
+         * </p>
+         */
         transient private static MFCReplayDecorator theInstance;
+        private MFCReplayDecorator() {};
+        /**
+         * <p>
+         * Constructor. Private to guarantee that only one instance of the replay
+         * generator exists.
+         * </p>
+         */
+        private MFCReplayDecorator() {
+        };
+        /**
+         * <p>
+         * Returns the instance of the MFCReplayDecorator.
+         * </p>
+         *
+         * @return instance of the MFCReplayDecorator.
+         */
         public static MFCReplayDecorator getInstance() {
                 if( theInstance==null ) {
+                if (theInstance == null) {
                         theInstance = new MFCReplayDecorator();
+                }
                 return theInstance;
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see de.ugoe.cs.eventbench.IReplayDecorator#getHeader()
+         */
         @Override
         public String getHeader() {
                 return "<?xml version=\"1.0\" encoding=\"UTF-16\"?>" + StringTools.ENDLINE +
                            "<log>" + StringTools.ENDLINE;
+                return "<?xml version=\"1.0\" encoding=\"UTF-16\"?>"
+                                + StringTools.ENDLINE + "<log>" + StringTools.ENDLINE;
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see de.ugoe.cs.eventbench.IReplayDecorator#getFooter()
+         */
         @Override
         public String getFooter() {
 …
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see de.ugoe.cs.eventbench.IReplayDecorator#getSessionHeader(int)
+         */
         @Override
         public String getSessionHeader(int sessionId) {
                 return " <session id=\""+sessionId+"\">" + StringTools.ENDLINE;
+                return " <session id=\"" + sessionId + "\">" + StringTools.ENDLINE;
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see de.ugoe.cs.eventbench.IReplayDecorator#getSessionFooter(int)
+         */
         @Override
         public String getSessionFooter(int sessionId) {
                 return " </session>" + StringTools.ENDLINE;
+        }
+}

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/MessageDefs.java

-                      r76
+                      r171
 package de.ugoe.cs.eventbench.windows;
+/**
+ * <p>
+ * Contains definitions of windows message codes, such that they can be used
+ * internally by their name and not their integer value, to improve the
+ * readability of the source code.
+ * </p>
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
 public interface MessageDefs {
         public static final int WM_NULL = 0;
         public static final int WM_CREATE = 1;

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/MessageHandler.java

-                      r75
+                      r171
 package de.ugoe.cs.eventbench.windows;
+/**
+ * <p>
+ * Base class to define custom message handlers, for messages that shall be
+ * handled differently during the parsing of usage logs. It provides dummy
+ * implementations for all required methods, such that implementations can only
+ * overwrite the parts they actually require and ignore the rest.
+ * </p>
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class MessageHandler {
+public class MessageHandler {
+        protected MessageHandler() {}
+        public void onStartElement() {}
+        public void onParameter(String name, String value) {}
+        public void onEndElement() {}
+        /**
+         * <p>
+         * Constructor. Protected to prohibit initialization of the base class
+         * itself.
+         * </p>
+         */
+        protected MessageHandler() {
+        }
+        /**
+         * <p>
+         * Called in the startElement() method of the {@link LogParser} when a
+         * msg-node begins.
+         * </p>
+         */
+        public void onStartElement() {
+        }
+        /**
+         * <p>
+         * Called by the {@link LogParser} to handle param-nodes.
+         * </p>
+         *
+         * @param name
+         *            name (type) of the parameter
+         * @param value
+         *            value of the parameter
+         */
+        public void onParameter(String name, String value) {
+        }
+        /**
+         * <p>
+         * Called in the endElement() method of {@link LogParser} when a msg-node
+         * ends.
+         * </p>
+         */
+        public void onEndElement() {
+        }
+}

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/SequenceSplitter.java

-                      r77
+                      r171
 import java.util.List;
+import de.ugoe.cs.eventbench.data.Event;
 import de.ugoe.cs.eventbench.windows.data.WindowsMessage;
 import de.ugoe.cs.util.console.Console;
+/**
+ * <p>
+ * Responsible to split sequences into subsequences, such that each subsequences
+ * contains exactly one event.
+ * </p>
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
 public class SequenceSplitter {
+        /**
+         * <p>
+         * Contains the current subsequence.
+         * </p>
+         */
         private List<WindowsMessage> currentSequence;
+        /**
+         * <p>
+         * Number of messages in the current sequences, that signal that a key or
+         * mouse button has been pressed down to which not yet a message has been
+         * found, that signals that the button has been released.
+         * </p>
+         */
         private int openDowns;
+        /**
+         * <p>
+         * Internal flag that signals if {@link #currentSequence} needs to be
+         * initialized.
+         * </p>
+         */
         private boolean initMessages;
+        /**
+         * <p>
+         * The {@link EventGenerator} used to convert the subsequences into
+         * {@link Event}s
+         * </p>
+         */
         private EventGenerator tokenGenerator;
+        /**
+         * <p>
+         * The event sequence generated.
+         * </p>
+         */
         private List<WindowsEvent> actionSequence;
+        /**
+         * <p>
+         * Constructor. Creates a new SequenceSplitter.
+         * </p>
+         */
         public SequenceSplitter() {
                 currentSequence = new LinkedList<WindowsMessage>();
 …
                 actionSequence = new LinkedList<WindowsEvent>();
+        }
+        /**
+         * <p>
+         * Called by the {@link LogParser} every time a message is parsed.
+         * </p>
+         *
+         * @param msg
+         *            message to be added
+         */
         public void addMessage(WindowsMessage msg) {
+                if( startOfSequence(msg) ) {
+                        if( !initMessages ) {
+                                WindowsEvent currentAction = tokenGenerator.generateEvent(currentSequence);
+                                if( currentAction!=null ) {
+                if (startOfSequence(msg)) {
+                        if (!initMessages) {
+                                WindowsEvent currentAction = tokenGenerator
+                                                .generateEvent(currentSequence);
+                                if (currentAction != null) {
                                         actionSequence.add(currentAction);
+                                }
                                 if( isKeyMessage(msg.getType()) && openDowns>0 ) {
+                                if (isKeyMessage(msg.getType()) && openDowns > 0) {
                                         Console.traceln("Key message found with open down mouse messages - will probabably result in a faulty sequence.");
+                                }
 …
+                        }
                         currentSequence = new LinkedList<WindowsMessage>();
+                }
                 if( isUpMessage(msg.getType()) ) {
                         if( openDowns>0 ) {
+                }
+                if (isUpMessage(msg.getType())) {
+                        if (openDowns > 0) {
                                 openDowns--;
+                        }
 …
                 currentSequence.add(msg);
+        }
+        /**
+         * <p>
+         * Returns the event sequence generated from the message that have been
+         * added.
+         * </p>
+         *
+         * @return generated event sequence
+         */
         public List<WindowsEvent> getSequence() {
                 return actionSequence;
+        }
+        /**
+         * <p>
+         * Called when a session in the log file is finished, i.e., a closing
+         * session-node is found.
+         * </p>
+         */
         public void endSession() {
+                WindowsEvent currentAction = tokenGenerator.generateEvent(currentSequence);
+                if( currentAction!=null ) {
+                WindowsEvent currentAction = tokenGenerator
+                                .generateEvent(currentSequence);
+                if (currentAction != null) {
                         actionSequence.add(currentAction);
+                }
+        }
+        /**
+         * <p>
+         * Checks if the message starts a new subsequence and returns the result.
+         * </p>
+         *
+         * @param msg
+         *            message that is checked
+         * @return true, if a new subsequence begins
+         */
         private boolean startOfSequence(WindowsMessage msg) {
                 boolean isStart = false;
                 int msgType = msg.getType();
                 if( isKeyMessage(msgType) ) {
+                if (isKeyMessage(msgType)) {
                         isStart = true;
+                }
                 if( isDownMessage(msgType) ) {
+                if (isDownMessage(msgType)) {
                         openDowns++;
                         if( openDowns==1 ) {
+                        if (openDowns == 1) {
                                 isStart = true;
+                        }
+                }
                 if( isDblclkMessage(msgType) ) {
+                if (isDblclkMessage(msgType)) {
                         openDowns++;
+                }
 …
+        }
+        /**
+         * <p>
+         * Checks if the type of a message is generated is a keyboard interaction.
+         * </p>
+         *
+         * @param msgType
+         *            type of the message
+         * @return true if it is a keyboard interaction; false otherwise
+         */
         private boolean isKeyMessage(int msgType) {
                 boolean isKeyMsg = false;
                 switch (msgType) {
                         case MessageDefs.WM_KEYDOWN:
                         case MessageDefs.WM_KEYUP:
                         case MessageDefs.WM_SYSKEYDOWN:
                         case MessageDefs.WM_SYSKEYUP:
                                 isKeyMsg = true;
                                 break;
                         default:
                                         break;
+                case MessageDefs.WM_KEYDOWN:
+                case MessageDefs.WM_KEYUP:
+                case MessageDefs.WM_SYSKEYDOWN:
+                case MessageDefs.WM_SYSKEYUP:
+                        isKeyMsg = true;
+                        break;
+                default:
+                        break;
+                }
                 return isKeyMsg;
+        }
+        /**
+         * <p>
+         * Checks if the type of a message indicates that the mouse has been pressed
+         * down.
+         * </p>
+         *
+         * @param msgType
+         *            type of the message
+         * @return true if it is mouse-down message; false otherwise
+         */
         private boolean isDownMessage(int msgType) {
                 boolean isDownMsg = false;
                 switch (msgType) {
                         case MessageDefs.WM_LBUTTONDOWN:
                         case MessageDefs.WM_RBUTTONDOWN:
                         case MessageDefs.WM_MBUTTONDOWN:
                         case MessageDefs.WM_XBUTTONDOWN:
                         case MessageDefs.WM_NCLBUTTONDOWN:
                         case MessageDefs.WM_NCRBUTTONDOWN:
                         case MessageDefs.WM_NCMBUTTONDOWN:
                         case MessageDefs.WM_NCXBUTTONDOWN:
                                 isDownMsg = true;
                                 break;
                         default:
                                 break;
+                case MessageDefs.WM_LBUTTONDOWN:
+                case MessageDefs.WM_RBUTTONDOWN:
+                case MessageDefs.WM_MBUTTONDOWN:
+                case MessageDefs.WM_XBUTTONDOWN:
+                case MessageDefs.WM_NCLBUTTONDOWN:
+                case MessageDefs.WM_NCRBUTTONDOWN:
+                case MessageDefs.WM_NCMBUTTONDOWN:
+                case MessageDefs.WM_NCXBUTTONDOWN:
+                        isDownMsg = true;
+                        break;
+                default:
+                        break;
+                }
                 return isDownMsg;
+        }
+        /**
+         * <p>
+         * Checks if the type of a message indicates that a double click has been
+         * performed.
+         * </p>
+         *
+         * @param msgType
+         *            type of the message
+         * @return true if it is a double click message; false otherwise
+         */
         private boolean isDblclkMessage(int msgType) {
                 boolean isDblclkMsg = false;
                 switch (msgType) {
                         case MessageDefs.WM_LBUTTONDBLCLK:
                         case MessageDefs.WM_RBUTTONDBLCLK:
                         case MessageDefs.WM_MBUTTONDBLCLK:
                         case MessageDefs.WM_XBUTTONDBLCLK:
                         case MessageDefs.WM_NCLBUTTONDBLCLK:
                         case MessageDefs.WM_NCRBUTTONDBLCLK:
                         case MessageDefs.WM_NCMBUTTONDBLCLK:
                         case MessageDefs.WM_NCXBUTTONDBLCLK:
                                 isDblclkMsg = true;
                                 break;
                         default:
                                 break;
+                case MessageDefs.WM_LBUTTONDBLCLK:
+                case MessageDefs.WM_RBUTTONDBLCLK:
+                case MessageDefs.WM_MBUTTONDBLCLK:
+                case MessageDefs.WM_XBUTTONDBLCLK:
+                case MessageDefs.WM_NCLBUTTONDBLCLK:
+                case MessageDefs.WM_NCRBUTTONDBLCLK:
+                case MessageDefs.WM_NCMBUTTONDBLCLK:
+                case MessageDefs.WM_NCXBUTTONDBLCLK:
+                        isDblclkMsg = true;
+                        break;
+                default:
+                        break;
+                }
                 return isDblclkMsg;
+        }
+        /**
+         * <p>
+         * Checks if the type of a message indicates that the mouse has been
+         * released.
+         * </p>
+         *
+         * @param msgType
+         *            type of the message
+         * @return true if it is mouse-up message; false otherwise
+         */
         private boolean isUpMessage(int msgType) {
                 boolean isUpMsg = false;
                 switch (msgType) {
                         case MessageDefs.WM_LBUTTONUP:
                         case MessageDefs.WM_RBUTTONUP:
                         case MessageDefs.WM_MBUTTONUP:
                         case MessageDefs.WM_XBUTTONUP:
                         case MessageDefs.WM_NCLBUTTONUP:
                         case MessageDefs.WM_NCRBUTTONUP:
                         case MessageDefs.WM_NCMBUTTONUP:
                         case MessageDefs.WM_NCXBUTTONUP:
                                 isUpMsg = true;
                                 break;
                         default:
                                 break;
+                case MessageDefs.WM_LBUTTONUP:
+                case MessageDefs.WM_RBUTTONUP:
+                case MessageDefs.WM_MBUTTONUP:
+                case MessageDefs.WM_XBUTTONUP:
+                case MessageDefs.WM_NCLBUTTONUP:
+                case MessageDefs.WM_NCRBUTTONUP:
+                case MessageDefs.WM_NCMBUTTONUP:
+                case MessageDefs.WM_NCXBUTTONUP:
+                        isUpMsg = true;
+                        break;
+                default:
+                        break;
+                }
                 return isUpMsg;
+        }
+}

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/WindowsEvent.java

-                      r87
+                      r171
 import de.ugoe.cs.eventbench.windows.data.WindowsMessage;
+// convenience class
+/**
+ * <p>
+ * Convenience class for working with Windows MFC events.
+ * </p>
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
 public class WindowsEvent extends ReplayableEvent<WindowsMessage> {
         /**
+         * <p>
          * Id for object serialization.
+         * </p>
          */
         private static final long serialVersionUID = 1L;
+        /**
+         * <p>
+         * Constructor. Creates a new WindowEvent.
+         * </p>
+         *
+         * @see de.ugoe.cs.eventbench.data.Event#Event(String)
+         * @param type
+         *            type of the event.
+         */
         public WindowsEvent(String type) {
                 super(type);

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/commands/CMDconvertDirToXml.java

-                      r52
+                      r171
 import de.ugoe.cs.util.console.Console;
+/**
+ * <p>
+ * Command to pre-process all files in a folder.
+ * </p>
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
 public class CMDconvertDirToXml implements Command {
+        /*
+         * (non-Javadoc)
+         *
+         * @see de.ugoe.cs.util.console.Command#help()
+         */
         @Override
         public void help() {
 …
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see de.ugoe.cs.util.console.Command#run(java.util.List)
+         */
         @Override
         public void run(List<Object> parameters) {
                 if( parameters.size() < 2 ) {
+                if (parameters.size() < 2) {
                         throw new InvalidParameterException();
+                }
 …
                 String target = (String) parameters.get(1);
                 boolean base64 = false;
                 if( parameters.size() == 3 ) {
+                if (parameters.size() == 3) {
                         base64 = Boolean.parseBoolean((String) parameters.get(2));
+                }
                 try {
                         new LogPreprocessor(base64).convertDirToXml(path, target);
 …
                         Console.println(e.getMessage());
+                }
+        }

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/commands/CMDconvertToXml.java

-                      r52
+                      r171
 import de.ugoe.cs.util.console.Console;
+/**
+ * <p>
+ * Command to pre-process a single file.
+ * </p>
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
 public class CMDconvertToXml implements Command {
+        /*
+         * (non-Javadoc)
+         *
+         * @see de.ugoe.cs.util.console.Command#help()
+         */
         @Override
         public void help() {
 …
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see de.ugoe.cs.util.console.Command#run(java.util.List)
+         */
         @Override
         public void run(List<Object> parameters) {
                 if( parameters.size() < 2 ) {
+                if (parameters.size() < 2) {
                         throw new InvalidParameterException();
+                }
 …
                 String target = (String) parameters.get(1);
                 boolean base64 = false;
                 if( parameters.size() == 3 ) {
+                if (parameters.size() == 3) {
                         base64 = Boolean.parseBoolean((String) parameters.get(2));
+                }
                 try {
                         new LogPreprocessor(base64).convertToXml(source, target);
 …
                         Console.println(e.getMessage());
+                }
+        }

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/commands/CMDparseXML.java

-                      r84
+                      r171
 import de.ugoe.cs.util.console.Console;
+/**
+ * <p>
+ * Command to parse an XML file with sessions monitored by EventBench's
+ * MFCUsageMonitor.
+ * </p>
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
 public class CMDparseXML implements Command {
+        /* (non-Javadoc)
+         * @see de.ugoe.cs.util.console.Command#help()
+         */
         @Override
         public void help() {
 …
+        }
+        /* (non-Javadoc)
+         * @see de.ugoe.cs.util.console.Command#run(java.util.List)
+         */
         @Override
         public void run(List<Object> parameters) {
                 String filename;
                 boolean countMessageOccurences = false;
                 try {
                         filename = (String) parameters.get(0);
+                        if( parameters.size()==2 ) {
+                                countMessageOccurences = Boolean.parseBoolean((String) parameters.get(1));
+                        if (parameters.size() == 2) {
+                                countMessageOccurences = Boolean
+                                                .parseBoolean((String) parameters.get(1));
+                        }
                 } catch (Exception e) {
                         throw new InvalidParameterException();
+                }
                 LogParser parser = new LogParser(countMessageOccurences);
                 parser.parseFile(filename);
                 List<List<WindowsEvent>> sequences = parser.getSequences();
                 if( GlobalDataContainer.getInstance().addData("sequences", sequences ) ) {
+                if (GlobalDataContainer.getInstance().addData("sequences", sequences)) {
                         Console.traceln("Old data \"" + "sequences" + "\" overwritten");
+                }
+                }
+        }

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/data/WindowTree.java

r157	r171
28	28	*
29	29	* @author Steffen Herbold
	30	* @version 1.0
30	31	*/
31	32	public class WindowTree {

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/data/WindowTreeNode.java

-                      r52
+                      r171
+ *
  * @author Steffen Herbold
+ * @version 1.0
  */
 public class WindowTreeNode {
 …
          */
         private List<WindowTreeNode> children;
         /**
          * <p>
 …
                         xmlString = parent.xmlRepresentation();
+                }
+                xmlString += "<window name=\"" + StringTools.xmlEntityReplacement(windowName) + "\" class=\""
+                                + StringTools.xmlEntityReplacement(className) + "\" resourceId=\"" + resourceId + "\" isModal=\""
+                                + isModal + "\"/>";
+                xmlString += "<window name=\""
+                                + StringTools.xmlEntityReplacement(windowName) + "\" class=\""
+                                + StringTools.xmlEntityReplacement(className)
+                                + "\" resourceId=\"" + resourceId + "\" isModal=\"" + isModal
+                                + "\"/>";
                 return xmlString;
+        }
+        /**
+         * <p>
+         * Returns the names of the parents and itself separated by dots, e.g.,
+         * "GrandParent.Parent.windowName"
+         * </p>
+         *
+         * @return names of the parents separated by dots
+         */
         public String getParentNames() {
                 String parentNames = "";
                 if (parent != null ) {
                         parentNames = parent.getParentNames()+".";
+                if (parent != null) {
+                        parentNames = parent.getParentNames() + ".";
+                }
                 parentNames += windowName;

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/data/WindowsMessage.java

-                      r141
+                      r171
 import de.ugoe.cs.util.StringTools;
+/**
+ * <p>
+ * Contains all informations about a windows message, i.e., all parameters that
+ * are read when a windows message is parsed as well as its target, hwnd, etc.
+ * </p>
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ *
+ */
 public class WindowsMessage implements IReplayable {
+        /**
+         * Id for object serialization.
+        /**
+         * <p>
+         * Id for object serialization.
+         * </p>
          */
         private static final long serialVersionUID = 1L;
+        /**
+         * <p>
+         * Type of the message.
+         * </p>
+         */
         final int type;
+        /**
+         * <p>
+         * Window class of the message target. Default: ""
+         * </p>
+         */
         private String windowClass = "";
+        /**
+         * <p>
+         * Resource Id of the message target. Default: 0
+         * </p>
+         */
         private int resourceId = 0;
+        /**
+         * <p>
+         * XML representation of the message target.
+         * </p>
+         */
         private String xmlWindowDescription = "";
+        /**
+         * <p>
+         * String that contains the names of all parent widgets and itself, separated by dots,
+         * e.g., "GrandParent.Parent.self".
+         * </p>
+         */
         private String parentNames = null;
+        /**
+         * <p>
+         * String that contains the window class of the parent widget.
+         * </p>
+         */
         private String parentClass = null;
+        /**
+         * <p>
+         * LPARAM of the message. Default: 0
+         * </p>
+         */
         private long LPARAM = 0;
+        /**
+         * <p>
+         * WPARAM of the message. Default: 0
+         * </p>
+         */
         private long WPARAM = 0;
+        /**
+         * <p>
+         * If the LPARAM contains a HWND, this string stores the target of the HWND.
+         * </p>
+         */
         private String LPARAMasWindowDesc = null;
+        /**
+         * <p>
+         * If the WPARAM contains a HWND, this string stores the target of the HWND.
+         * </p>
+         */
         private String WPARAMasWindowDesc = null;
+        /**
+         * <p>
+         * Delay after sending the messages during a replay. Default: 0
+         * </p>
+         */
         private int delay = 0;
+        /**
+         * <p>
+         * A map of all parameters, associated with the message, created during the
+         * parsing of messages from the logs {@code param}-nodes.
+         * </p>
+         */
         private Map<String, String> params = new HashMap<String, String>();
+        /**
+         * <p>
+         * Constructor. Creates a new message with a given message type.
+         * </p>
+         *
+         * @param type
+         *            type of the message
+         */
         public WindowsMessage(int type) {
                 this.type = type;
+        }
+        /**
+         * <p>
+         * Adds a parameter to the message.
+         * </p>
+         *
+         * @param type
+         *            type descriptor of the parameter
+         * @param value
+         *            value of the parameter
+         */
         public void addParameter(String type, String value) {
                 params.put(type, value);
 …
+        }
+        /**
+         * <p>
+         * Returns the type of the message.
+         * </p>
+         *
+         * @return type of the message
+         */
         public int getType() {
                 return type;
+        }
+        /**
+         * <p>
+         * Returns the value of a parameter, given its type. If the parameter is not
+         * found, {@code null} is returned.
+         * </p>
+         *
+         * @param type
+         *            type of the parameter
+         * @return value of the parameter
+         */
         public String getParameter(String type) {
                 return params.get(type);
+        }
+        /**
+         * <p>
+         * Returns the window class of the message target.
+         * </p>
+         *
+         * @return window class of the message target
+         */
         public String getWindowClass() {
                 return windowClass;
+        }
+        /**
+         * <p>
+         * Returns the HWND the message is addressed to.
+         * </p>
+         *
+         * @return HWND the message is addressed to
+         */
         public int getHwnd() {
                 int hwnd = -1;
 …
+        }
+        /**
+         * <p>
+         * Returns the resource Id of the message target.
+         * </p>
+         *
+         * @return resource Id of the message target
+         */
         public int getWindowResourceId() {
                 return resourceId;
+        }
+        /**
+         * <p>
+         * Two {@link WindowsMessage} are equal, if their {@link #type},
+         * {@link #xmlWindowDescription}, and {@link #params} are equal.
+         * </p>
+         *
+         * @see java.lang.Object#equals(java.lang.Object)
+         */
         @Override
         public boolean equals(Object other) {
                 if( other==this) {
+                if (other == this) {
                         return true;
+                }
 …
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see java.lang.Object#hashCode()
+         */
         @Override
         public int hashCode() {
 …
+        }
+        /**
+         * <p>
+         * Returns a string representation of the message of the form
+         * "msg[target=HWND;type=TYPE]".
+         * </p>
+         *
+         * @see java.lang.Object#toString()
+         */
         @Override
         public String toString() {
 …
+        }
+        /**
+         * <p>
+         * Retrieves the target string of a message from a given {@link WindowTree}
+         * through looking up the HWND the message is addressed to in the window
+         * tree.
+         * </p>
+         *
+         * @param windowTree
+         *            {@link WindowTree} from which the target is extracted
+         * @throws InvalidParameterException
+         *             thrown if HWND is not contained in windowTree
+         */
         public void setTarget(WindowTree windowTree)
                         throws InvalidParameterException {
 …
                         parentNames = node.getParentNames();
                         WindowTreeNode parent = node.getParent();
                         if( parent==null ) {
+                        if (parent == null) {
                                 parentClass = "";
                         } else {
 …
+        }
+        /**
+         * <p>
+         * Sets the LPARAM of a message.
+         * </p>
+         *
+         * @param paramValue
+         *            value of the LPARAM
+         */
         public void setLPARAM(long paramValue) {
                 LPARAM = paramValue;
+        }
+        /**
+         * <p>
+         * Sets the WPARAM of a message.
+         * </p>
+         *
+         * @param paramValue
+         *            value of the WPARAM
+         */
         public void setWPARAM(long paramValue) {
                 WPARAM = paramValue;
+        }
+        /**
+         * <p>
+         * Returns the LPARAM of a message.
+         * </p>
+         *
+         * @return LPARAM of the message
+         */
         public long getLPARAM() {
                 return LPARAM;
+        }
+        /**
+         * <p>
+         * Returns the WPARAM of a message.
+         * </p>
+         *
+         * @return WPARAM of the message
+         */
         public long getWPARAM() {
                 return WPARAM;
+        }
+        /**
+         * <p>
+         * If the LPARAM contains a HWND, this function can be used to set a target
+         * string to identify the HWND at run-time.
+         * </p>
+         *
+         * @param windowDesc
+         *            target string
+         */
         public void setLPARAMasWindowDesc(String windowDesc) {
                 LPARAMasWindowDesc = windowDesc;
+        }
+        /**
+         * <p>
+         * If the WPARAM contains a HWND, this function can be used to set a target
+         * string to identify the HWND at run-time.
+         * </p>
+         *
+         * @param windowDesc
+         *            target string
+         */
         public void setWPARAMasWindowDesc(String windowDesc) {
                 WPARAMasWindowDesc = windowDesc;
+        }
+        /**
+         * <p>
+         * If the LPARAM contains a HWND and the target string for the HWND is set,
+         * this function returns the target string. Otherwise, {@code null} is
+         * returned.
+         * </p>
+         *
+         * @return target string if available; {@code null} otherwise
+         */
         public String getLPARAMasWindowDesc() {
                 return LPARAMasWindowDesc;
+        }
+        /**
+         * <p>
+         * If the WPARAM contains a HWND and the target string for the HWND is set,
+         * this function returns the target string. Otherwise, {@code null} is
+         * returned.
+         * </p>
+         *
+         * @return target string if available; {@code null} otherwise
+         */
         public String getWPARAMasWindowDesc() {
                 return WPARAMasWindowDesc;
+        }
+        /**
+         * <p>
+         * Returns the target string of the message.
+         * </p>
+         *
+         * @return target string of the message
+         */
         public String getXmlWindowDescription() {
                 return xmlWindowDescription;
+        }
+        /**
+         * <p>
+         * Sets the target string manually.
+         * </p>
+         *
+         * @param xmlWindowDescription
+         *            target string
+         */
         public void setXmlWindowDescription(String xmlWindowDescription) {
                 this.xmlWindowDescription = xmlWindowDescription;
+        }
+        /**
+         * <p>
+         * Returns the delay after this message during replays.
+         * </p>
+         *
+         * @return delay after this message
+         */
         public int getDelay() {
                 return delay;
+        }
+        /**
+         * <p>
+         * Sets the delay after this message during replays.
+         * </p>
+         *
+         * @param delay
+         *            delay after this message
+         */
         public void setDelay(int delay) {
                 this.delay = delay;
+        }
+        /**
+         * <p>
+         * Returns the parent names separated by dots, e.g., "GrandParent.Parent".
+         * </p>
+         *
+         * @return names of the parents
+         */
         public String getParentNames() {
                 return parentNames;
+        }
+        /**
+         * <p>
+         * Returns the window class of the parent.
+         * </p>
+         *
+         * @return window classes of the parents
+         */
         public String getParentClass() {
                 return parentClass;
+        }
+        /**
+         * <p>
+         * Returns the number of parameters stored together with this message.
+         * </p>
+         *
+         * @return
+         */
         public int getNumParams() {
                 return params.size();
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see de.ugoe.cs.eventbench.data.IReplayable#getReplay()
+         */
+        @Override
         public String getReplay() {
                 StringBuilder currentMsgStr = new StringBuilder(400);
                 currentMsgStr.append("  <msg type=\""+type+"\" ");
                 currentMsgStr.append("LPARAM=\""+LPARAM+"\" ");
                 currentMsgStr.append("WPARAM=\""+WPARAM+"\" ");
                 currentMsgStr.append("delay=\""+delay+"\">");
                 if( LPARAMasWindowDesc!=null ) {
+                currentMsgStr.append("  <msg type=\"" + type + "\" ");
+                currentMsgStr.append("LPARAM=\"" + LPARAM + "\" ");
+                currentMsgStr.append("WPARAM=\"" + WPARAM + "\" ");
+                currentMsgStr.append("delay=\"" + delay + "\">");
+                if (LPARAMasWindowDesc != null) {
                         currentMsgStr.append(StringTools.ENDLINE);
                         currentMsgStr.append("   <LPARAM>");
 …
                         currentMsgStr.append(StringTools.ENDLINE);
                         currentMsgStr.append("</LPARAM>");
+                }
                 if( WPARAMasWindowDesc!=null ) {
+                }
+                if (WPARAMasWindowDesc != null) {
                         currentMsgStr.append(StringTools.ENDLINE);
                         currentMsgStr.append("   <WPARAM>");
 …
                 return currentMsgStr.toString();
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see de.ugoe.cs.eventbench.data.IReplayable#getTarget()
+         */
+        @Override
         public String getTarget() {
                 return xmlWindowDescription;

Context Navigation

Legend:

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/EventGenerator.java

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/HandlerCreate.java

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/HandlerDestroy.java

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/HandlerSetText.java

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/LogParser.java

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/LogPreprocessor.java

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/MFCReplayDecorator.java

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/MessageDefs.java

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/MessageHandler.java

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/SequenceSplitter.java

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/WindowsEvent.java

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/commands/CMDconvertDirToXml.java

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/commands/CMDconvertToXml.java

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/commands/CMDparseXML.java

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/data/WindowTree.java

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/data/WindowTreeNode.java

trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/windows/data/WindowsMessage.java

Download in other formats: