+ * This data structure can be used by the commands to store any {@link Object}.
+ * The data is stored in a key-value map, with strings as keys.
+ *
+ *
+ * This class is implemented as a singleton, as more than one data container
+ * does not serves no purpose.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class GlobalDataContainer implements Serializable {
+
+ /**
+ *
+ * Instance of the {@link GlobalDataContainer} (implemented as singleton).
+ *
+ */
+ transient private static GlobalDataContainer theInstance = null;
+
+ /**
+ * dataObjects;
+
+ /**
+ *
+ * Returns the instance of the container. If it does not yet exist, the data
+ * container is created.
+ *
+ *
+ * @return instance of the container
+ */
+ public static GlobalDataContainer getInstance() {
+ if (theInstance == null) {
+ theInstance = new GlobalDataContainer();
+ }
+ return theInstance;
+ }
+
+ /**
+ *
+ * Manual serialization of the object. Necessary to guarantee the singleton
+ * property.
+ *
+ *
+ * @param s
+ * output stream for the serialization
+ * @throws IOException
+ * thrown if there is problem writing to the output stream
+ */
+ private void writeObject(ObjectOutputStream s) throws IOException {
+ s.defaultWriteObject();
+ s.writeObject(dataObjects);
+ }
+
+ /**
+ *
+ * Manual de-serialization of the object. Necessary to guarantee the
+ * singleton property.
+ *
+ * @param s
+ * input stream for the de-serialization
+ * @throws IOException
+ * thrown if there is problem reading from the input stream
+ * @throws ClassNotFoundException
+ * thrown if there is a problem reading from the input stream
+ */
+ @SuppressWarnings("unchecked")
+ private void readObject(ObjectInputStream s) throws IOException,
+ ClassNotFoundException {
+ s.defaultReadObject();
+ if (theInstance == null) {
+ theInstance = new GlobalDataContainer();
+ }
+ theInstance.dataObjects = (Map) s.readObject();
+ }
+
+ /**
+ *
+ * Manual de-serialization to guarantee the singleton property.
+ *
+ *
+ * @return instance of the container
+ */
+ private Object readResolve() {
+ return theInstance;
+ }
+
+ /**
+ *
+ * Constructor. Creates a new GlobalDataContainer. Private to guarantee the
+ * singleton property.
+ *
+ */
+ private GlobalDataContainer() {
+ dataObjects = new HashMap();
+ }
+
+ /**
+ *
+ * Adds data to the container.
+ *
+ *
+ * @param key
+ * key that identifies the data
+ * @param data
+ * data that is stored
+ * @return true, if an old entry was overwritten; false otherwise
+ */
+ public boolean addData(String key, Object data) {
+ Object previousEntry = dataObjects.put(key, data);
+ return previousEntry != null;
+ }
+
+ /**
+ *
+ * Removes data from the container.
+ *
+ *
+ * @param key
+ * key of the data to be removed
+ * @return true, if the object was removed; false if it was not present
+ */
+ public boolean removeData(String key) {
+ Object previousEntry = dataObjects.remove(key);
+ return previousEntry != null;
+ }
+
+ /**
+ *
+ * Returns the data associated with a key or {@code null} if no data is
+ * stored for the key.
+ *
+ *
+ * @param key
+ * key whose data is returned
+ * @return data associated with the key; {@code null} if no data is
+ * available
+ */
+ public Object getData(String key) {
+ return dataObjects.get(key);
+ }
+
+ /**
+ *
+ * Resets the data container, i.e., deletes all its contents.
+ *
+ */
+ public void reset() {
+ dataObjects = new HashMap();
+ }
+
+ /**
+ *
+ * Returns all keys of collections of sequences contained in the storage.
+ *
+ *
+ * @return keys of all collections of sequences contained in the storage
+ */
+ public Collection getAllSequencesNames() {
+ Collection allSequencesNames = new LinkedList();
+ for (Entry entry : dataObjects.entrySet()) {
+ if( SequenceInstanceOf.isCollectionOfSequences(entry.getValue())) {
+ allSequencesNames.add(entry.getKey());
+ }
+ }
+ return allSequencesNames;
+ }
+
+ /**
+ *
+ * Returns the keys of all {@link IStochasticProcess}s contained in the
+ * storage.
+ *
+ *
+ * @return keys of all {@link IStochasticProcess}s contained in the storage
+ */
+ public Collection getAllModelNames() {
+ Collection modelNames = new LinkedList();
+ for (Entry entry : dataObjects.entrySet()) {
+ if (entry.getValue() instanceof IStochasticProcess) {
+ modelNames.add(entry.getKey());
+ }
+ }
+ return modelNames;
+ }
+
+ /**
+ *
+ * Returns the keys of all objects contained in the storage.
+ *
+ *
+ * @return keys of all objects in the storage
+ */
+ public Collection getAllKeys() {
+ return dataObjects.keySet();
+ }
+
+}
Index: /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/EFGModelGenerator.java
===================================================================
--- /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/EFGModelGenerator.java (revision 426)
+++ /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/EFGModelGenerator.java (revision 426)
@@ -0,0 +1,132 @@
+package de.ugoe.cs.eventbench.efg;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+
+import de.ugoe.cs.eventbench.commands.CMDupdateModel;
+import de.ugoe.cs.eventbench.data.Event;
+import de.ugoe.cs.eventbench.efg.data.EFGEvent;
+import de.ugoe.cs.eventbench.models.DeterministicFiniteAutomaton;
+import de.ugoe.cs.eventbench.models.FirstOrderMarkovModel;
+import edu.umd.cs.guitar.model.GUITARConstants;
+import edu.umd.cs.guitar.model.IO;
+import edu.umd.cs.guitar.model.data.EFG;
+import edu.umd.cs.guitar.model.data.EventGraphType;
+import edu.umd.cs.guitar.model.data.EventType;
+
+/**
+ *
+ * Provides functionality to generates models defined in the package
+ * de.ugoe.cs.eventbench.models from EFGs.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class EFGModelGenerator {
+
+ /**
+ *
+ * Generates a {@link FirstOrderMarkovModel} from an EFG. In the generated
+ * model, all following events are equally possible, i.e., the model is
+ * equal to a {@link DeterministicFiniteAutomaton}. However, through further
+ * training (e.g., {@link CMDupdateModel}) this can be changed.
+ *
+ *
+ * @param efgFileName
+ * name of the EFG file
+ * @return model generated from the EFG
+ */
+ public FirstOrderMarkovModel efgToFirstOrderMarkovModel(String efgFileName) {
+ EFG efg = (EFG) IO.readObjFromFile(efgFileName, EFG.class);
+
+ Collection>> subsequences = generateEdgeSequences(efg);
+ FirstOrderMarkovModel model = new FirstOrderMarkovModel(new Random());
+ model.train(subsequences);
+ return model;
+ }
+
+ /**
+ *
+ * Generates a {@link DeterministicFiniteAutomaton} from an EFG.
+ *
+ *
+ * @param efgFileName
+ * name of the EFG file
+ * @return model generated from the EFG
+ */
+ public DeterministicFiniteAutomaton efgToDeterministicFiniteAutomaton(
+ String efgFileName) {
+ EFG efg = (EFG) IO.readObjFromFile(efgFileName, EFG.class);
+
+ Collection>> subsequences = generateEdgeSequences(efg);
+ DeterministicFiniteAutomaton model = new DeterministicFiniteAutomaton(
+ new Random());
+ model.train(subsequences);
+ return model;
+ }
+
+ /**
+ *
+ * Extracts the graph structure from the EFG. The result is a set of
+ * sequences, where each sequence has length two and represents an edge in
+ * the EFG.
+ *
+ *
+ * @param efg
+ * EFG for which the edge sequence set is generated
+ * @return edge sequence set
+ */
+ private Collection>> generateEdgeSequences(EFG efg) {
+ List> events = createEvents(efg);
+ /*
+ * getEventGraph returns an adjacency matrix, i.e., a square matrix of
+ * efgEvents.size(), where a 1 in row i, column j means an edge
+ * efgEvents.get(i)->efgEvents.get(j) exists.
+ */
+ EventGraphType efgGraph = efg.getEventGraph();
+ Collection>> subsequences = new LinkedList>>();
+
+ int efgSize = events.size();
+ for (int row = 0; row < efgSize; row++) {
+ for (int col = 0; col < efgSize; col++) {
+ int relation = efgGraph.getRow().get(row).getE().get(col);
+ // otherEvent is followed by currentEvent
+ if (relation != GUITARConstants.NO_EDGE) {
+ List> edge = new LinkedList>();
+ edge.add(events.get(row));
+ edge.add(events.get(col));
+ subsequences.add(edge);
+ }
+ }
+ }
+ return subsequences;
+ }
+
+ /**
+ *
+ * Extracts creates {@link EFGEvent} for every event contained in the EFG.
+ *
+ *
+ * @param efg
+ * EFG for which the events are created
+ * @return list of events
+ */
+ private List> createEvents(EFG efg) {
+ List efgEvents = efg.getEvents().getEvent();
+ List> myEvents = new ArrayList>(efgEvents.size());
+ for (EventType event : efgEvents) {
+ /*
+ * the widgetId and eventId are only hash values, the
+ * "interpretation" is found in the GUI file.
+ */
+ Event myEvent = new EFGEvent(event.getEventId());
+ myEvent.setTarget(event.getWidgetId());
+ myEvents.add(myEvent);
+ }
+ return myEvents;
+ }
+}
Index: /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/EFGReplayDecorator.java
===================================================================
--- /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/EFGReplayDecorator.java (revision 426)
+++ /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/EFGReplayDecorator.java (revision 426)
@@ -0,0 +1,95 @@
+package de.ugoe.cs.eventbench.efg;
+
+import de.ugoe.cs.eventbench.IReplayDecorator;
+import de.ugoe.cs.util.StringTools;
+
+/**
+ *
+ * {@link IReplayDecorator} for replays generated for the GUITAR suite.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class EFGReplayDecorator implements IReplayDecorator {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * The instance of the {@link EFGReplayDecorator} (implemented as
+ * singleton).
+ *
+ */
+ transient private static EFGReplayDecorator theInstance;
+
+ /**
+ *
+ * Constructor. Private to guarantee that only one instance of the replay
+ * generator exists.
+ *
+ */
+ private EFGReplayDecorator() {
+ };
+
+ /**
+ *
+ * Returns the instance of the MFCReplayDecorator.
+ *
+ *
+ * @return instance of the MFCReplayDecorator.
+ */
+ public static EFGReplayDecorator getInstance() {
+ if (theInstance == null) {
+ theInstance = new EFGReplayDecorator();
+ }
+ return theInstance;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.eventbench.IReplayDecorator#getHeader()
+ */
+ @Override
+ public String getHeader() {
+ return ""
+ + StringTools.ENDLINE + "" + StringTools.ENDLINE;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.eventbench.IReplayDecorator#getFooter()
+ */
+ @Override
+ public String getFooter() {
+ return " ";
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.eventbench.IReplayDecorator#getSessionHeader(int)
+ */
+ @Override
+ public String getSessionHeader(int sessionId) {
+ return "";
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.eventbench.IReplayDecorator#getSessionFooter(int)
+ */
+ @Override
+ public String getSessionFooter(int sessionId) {
+ return "";
+ }
+
+}
Index: /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/GUITARTestCaseParser.java
===================================================================
--- /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/GUITARTestCaseParser.java (revision 426)
+++ /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/GUITARTestCaseParser.java (revision 426)
@@ -0,0 +1,109 @@
+package de.ugoe.cs.eventbench.efg;
+
+import java.io.File;
+import java.util.LinkedList;
+import java.util.List;
+
+import de.ugoe.cs.eventbench.data.Event;
+import de.ugoe.cs.eventbench.efg.data.EFGEvent;
+import edu.umd.cs.guitar.model.IO;
+import edu.umd.cs.guitar.model.data.EFG;
+import edu.umd.cs.guitar.model.data.EventType;
+import edu.umd.cs.guitar.model.data.StepType;
+import edu.umd.cs.guitar.model.data.TestCase;
+
+/**
+ *
+ * Parser for GUITAR test case files.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class GUITARTestCaseParser {
+
+ /**
+ *
+ * Name of the EFG file for the application the test cases that are parsed
+ * are generated for.
+ *
+ */
+ private String efgFileName = null;
+
+ /**
+ *
+ * Internal handle to the parsed EFG.
+ *
+ */
+ private EFG efg = null;
+
+ /**
+ *
+ * Constructor. Creates a new GUITARTestCaseParser. No EFG file is
+ * associated with this parser.
+ *
+ */
+ public GUITARTestCaseParser() {
+
+ }
+
+ /**
+ *
+ * Constructor. Creates a new GUITARTestCaseParser.
+ *
+ *
+ * @param efgFileName
+ * EFG file associated with the test cases that are parsed.
+ */
+ public GUITARTestCaseParser(String efgFileName) {
+ this.efgFileName = efgFileName;
+ }
+
+ /**
+ *
+ * Parses a GUITAR test case file and returns its contents as an event
+ * sequence.
+ *
+ *
+ * @param testcaseFile
+ * file that is parsed
+ * @return event sequence describing the test case
+ */
+ public List> parseTestCaseFile(File testcaseFile) {
+ TestCase testcase = (TestCase) IO.readObjFromFile(
+ testcaseFile.getAbsolutePath(), TestCase.class);
+ List steps = testcase.getStep();
+ List> sequence = new LinkedList>();
+ for (StepType step : steps) {
+ String eventId = step.getEventId();
+ EFGEvent event = new EFGEvent(eventId);
+ event.setTarget(getWidgetId(eventId));
+ sequence.add(event);
+ }
+ return sequence;
+ }
+
+ /**
+ *
+ * If {@link #efgFileName} is specified, this function retrieves the
+ * widgetId of the widget the event with id eventId belongs to from the EFG.
+ *
+ *
+ * @param eventId
+ * @return widgetId of the associated widget; null if {@link #efgFileName}
+ * ==null or no widgetId for the event is found in the EFG
+ */
+ private String getWidgetId(String eventId) {
+ if (eventId != null && efgFileName != null) {
+ if (efg == null) {
+ efg = (EFG) IO.readObjFromFile(efgFileName, EFG.class);
+ }
+ for (EventType event : efg.getEvents().getEvent()) {
+ if (eventId.equals(event.getEventId())) {
+ return event.getWidgetId();
+ }
+ }
+ }
+ return null;
+ }
+}
Index: /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/commands/CMDefgTestCasesToSequences.java
===================================================================
--- /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/commands/CMDefgTestCasesToSequences.java (revision 426)
+++ /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/commands/CMDefgTestCasesToSequences.java (revision 426)
@@ -0,0 +1,83 @@
+package de.ugoe.cs.eventbench.efg.commands;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.security.InvalidParameterException;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
+import de.ugoe.cs.eventbench.CommandHelpers;
+import de.ugoe.cs.eventbench.data.Event;
+import de.ugoe.cs.eventbench.data.GlobalDataContainer;
+import de.ugoe.cs.eventbench.efg.GUITARTestCaseParser;
+import de.ugoe.cs.util.console.Command;
+import de.ugoe.cs.util.console.Console;
+
+/**
+ *
+ * Command to load a set of sequences from a set of GUITAR test cases.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class CMDefgTestCasesToSequences implements Command {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.util.console.Command#run(java.util.List)
+ */
+ @Override
+ public void run(List parameters) {
+ String foldername;
+ String sequencesName;
+ String efgFileName = null;
+ try {
+ foldername = (String) parameters.get(0);
+ sequencesName = (String) parameters.get(1);
+ if (parameters.size() >= 3) {
+ efgFileName = (String) parameters.get(2);
+ }
+ } catch (Exception e) {
+ throw new InvalidParameterException();
+ }
+
+ File folder = new File(foldername);
+
+ File[] testcaseFiles = folder.listFiles( new FilenameFilter() {
+ @Override
+ public boolean accept(File dir, String name) {
+ return name.endsWith(".tst");
+ }
+ });
+ Collection>> sequences = new LinkedList>>();
+ GUITARTestCaseParser parser;
+ if (efgFileName == null) {
+ parser = new GUITARTestCaseParser();
+ } else {
+ parser = new GUITARTestCaseParser(efgFileName);
+ }
+ for (File testcaseFile : testcaseFiles) {
+ Console.traceln("Loading from file "
+ + testcaseFile.getAbsolutePath());
+ sequences.add(parser.parseTestCaseFile(testcaseFile));
+ }
+ if (GlobalDataContainer.getInstance().addData(sequencesName, sequences)) {
+ CommandHelpers.dataOverwritten(sequencesName);
+ }
+
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.util.console.Command#help()
+ */
+ @Override
+ public void help() {
+ Console.println("Usage: efgTestCasesToSequences {}");
+ }
+
+}
Index: /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/commands/CMDefgToDFA.java
===================================================================
--- /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/commands/CMDefgToDFA.java (revision 426)
+++ /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/commands/CMDefgToDFA.java (revision 426)
@@ -0,0 +1,55 @@
+package de.ugoe.cs.eventbench.efg.commands;
+
+import java.security.InvalidParameterException;
+import java.util.List;
+
+import de.ugoe.cs.eventbench.data.GlobalDataContainer;
+import de.ugoe.cs.eventbench.efg.EFGModelGenerator;
+import de.ugoe.cs.eventbench.models.DeterministicFiniteAutomaton;
+import de.ugoe.cs.util.console.Command;
+import de.ugoe.cs.util.console.Console;
+
+/**
+ *
+ * Command to that loads an EFG and creates Deterministic Finite Automaton (DFA)
+ * with the same structure.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class CMDefgToDFA implements Command {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.util.console.Command#run(java.util.List)
+ */
+ @Override
+ public void run(List parameters) {
+ String filename;
+ String modelname;
+ try {
+ filename = (String) parameters.get(0);
+ modelname = (String) parameters.get(1);
+ } catch (Exception e) {
+ throw new InvalidParameterException();
+ }
+
+ EFGModelGenerator modelGenerator = new EFGModelGenerator();
+ DeterministicFiniteAutomaton model = modelGenerator
+ .efgToDeterministicFiniteAutomaton(filename);
+ GlobalDataContainer.getInstance().addData(modelname, model);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.util.console.Command#help()
+ */
+ @Override
+ public void help() {
+ Console.println("Usage: efgToDFA ");
+ }
+
+}
Index: /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/commands/CMDefgToMM.java
===================================================================
--- /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/commands/CMDefgToMM.java (revision 426)
+++ /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/commands/CMDefgToMM.java (revision 426)
@@ -0,0 +1,55 @@
+package de.ugoe.cs.eventbench.efg.commands;
+
+import java.security.InvalidParameterException;
+import java.util.List;
+
+import de.ugoe.cs.eventbench.data.GlobalDataContainer;
+import de.ugoe.cs.eventbench.efg.EFGModelGenerator;
+import de.ugoe.cs.eventbench.models.FirstOrderMarkovModel;
+import de.ugoe.cs.util.console.Command;
+import de.ugoe.cs.util.console.Console;
+
+/**
+ *
+ * Command to that loads an EFG and creates a first-order Markov model with the
+ * same structure.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class CMDefgToMM implements Command {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.util.console.Command#run(java.util.List)
+ */
+ @Override
+ public void run(List parameters) {
+ String filename;
+ String modelname;
+ try {
+ filename = (String) parameters.get(0);
+ modelname = (String) parameters.get(1);
+ } catch (Exception e) {
+ throw new InvalidParameterException();
+ }
+
+ EFGModelGenerator modelGenerator = new EFGModelGenerator();
+ FirstOrderMarkovModel model = modelGenerator
+ .efgToFirstOrderMarkovModel(filename);
+ GlobalDataContainer.getInstance().addData(modelname, model);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.util.console.Command#help()
+ */
+ @Override
+ public void help() {
+ Console.println("Usage: efgToMM ");
+ }
+
+}
Index: /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/data/EFGEvent.java
===================================================================
--- /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/data/EFGEvent.java (revision 426)
+++ /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/data/EFGEvent.java (revision 426)
@@ -0,0 +1,34 @@
+package de.ugoe.cs.eventbench.efg.data;
+
+import de.ugoe.cs.eventbench.data.ReplayableEvent;
+
+/**
+ *
+ * Convenience class for working with EFGEvents.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class EFGEvent extends ReplayableEvent {
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Constructor. Creates a new EFGEvent.
+ *
+ *
+ * @param eventId
+ * EventId of the event in the EFG and GUI files
+ */
+ public EFGEvent(String eventId) {
+ super(eventId);
+ this.addReplayEvent(new EFGReplayable(eventId));
+ }
+}
Index: /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/data/EFGReplayable.java
===================================================================
--- /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/data/EFGReplayable.java (revision 426)
+++ /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/efg/data/EFGReplayable.java (revision 426)
@@ -0,0 +1,66 @@
+package de.ugoe.cs.eventbench.efg.data;
+
+import de.ugoe.cs.eventbench.data.IReplayable;
+import de.ugoe.cs.util.StringTools;
+
+/**
+ *
+ * {@link IReplayable} used to generate test cases for the GUITAR suite.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class EFGReplayable implements IReplayable {
+
+ /**
+ *
+ * EventId in the EFG and GUI files.
+ *
+ */
+ String eventId;
+
+ /**
+ *
+ * Id for object serialization.
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ *
+ * Constructor. Creates a new {@link EFGReplayable}.
+ *
+ *
+ * @param eventId
+ */
+ public EFGReplayable(String eventId) {
+ this.eventId = eventId;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.eventbench.data.IReplayable#getReplay()
+ */
+ @Override
+ public String getReplay() {
+ StringBuilder replay = new StringBuilder();
+ replay.append("" + StringTools.ENDLINE);
+ replay.append("" + eventId + " " + StringTools.ENDLINE);
+ replay.append("false " + StringTools.ENDLINE);
+ replay.append(" " + StringTools.ENDLINE);
+ return replay.toString();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.eventbench.data.IReplayable#getTarget()
+ */
+ @Override
+ public String getTarget() {
+ return null; // target indirectly included in replay through the eventId
+ }
+
+}
Index: /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/jfc/JFCLogParser.java
===================================================================
--- /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/jfc/JFCLogParser.java (revision 426)
+++ /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/jfc/JFCLogParser.java (revision 426)
@@ -0,0 +1,281 @@
+package de.ugoe.cs.eventbench.jfc;
+
+import java.awt.event.FocusEvent;
+import java.awt.event.MouseEvent;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.security.InvalidParameterException;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.parsers.SAXParser;
+import javax.xml.parsers.SAXParserFactory;
+
+import org.xml.sax.Attributes;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+import org.xml.sax.helpers.DefaultHandler;
+
+import de.ugoe.cs.eventbench.jfc.data.JFCEvent;
+import de.ugoe.cs.util.console.Console;
+
+/**
+ *
+ * This class provides functionality to parse XML log files generated by the
+ * JFCMonitor of EventBench. The result of parsing a file is a collection of
+ * event sequences.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class JFCLogParser extends DefaultHandler {
+
+ /**
+ *
+ * Collection of event sequences that is contained in the log file, which is
+ * parsed.
+ *
+ */
+ private Collection> sequences;
+
+ /**
+ *
+ * Internal handle to the event that is currently being parsed.
+ *
+ */
+ private JFCEvent currentEvent;
+
+ /**
+ *
+ * Internal handle to the event sequence that is currently being parsed.
+ *
+ */
+ private List currentSequence = null;
+
+ /**
+ *
+ * Internally used string to build a string representing a component-node.
+ *
+ */
+ private String componentString;
+
+ /**
+ *
+ * Enumeration to differentiate if a parameter belongs to an event, a source
+ * or the parent of a source.
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+ private enum ParamSource {
+ EVENT, SOURCE, PARENT, COMPONENT
+ };
+
+ /**
+ *
+ * Specifies whether the parameters that are currently being read belong the
+ * the event, the source or the parent.
+ *
+ */
+ ParamSource paramSource = null;
+
+ private Collection eventFilter;
+
+ /**
+ *
+ * Constructor. Creates a new JFCLogParser with a default event filter.
+ * This ignores focus events, mouse pressed, and mouse released events.
+ *
+ */
+ public JFCLogParser() {
+ sequences = new LinkedList>();
+ currentSequence = new LinkedList();
+ setupDefaultEventFilter();
+ }
+
+ /**
+ *
+ * Constructor. Creates a new JFCLogParser with a specific event filter.
+ * The events in the provided collection are ignored by the parser.
+ * As events, the constants of the different event classes must be used.
+ * E.g. creating a collection and putting
+ * MouseEvent.MOUSE_PRESSED will cause the parser to ignore
+ * all mouse pressed events. If the provided collection is null, no event
+ * is ignored.
+ *
+ *
+ * @param ignoredEvents the events to be ignored by the parser, can be null
+ */
+ public JFCLogParser(Collection ignoredEvents) {
+ sequences = new LinkedList>();
+ currentSequence = new LinkedList();
+ eventFilter = ignoredEvents;
+ }
+
+ /**
+ *
+ * creates a default event filter that ignores focus changes, mouse pressed
+ * and mouse released events.
+ *
+ */
+ private void setupDefaultEventFilter() {
+ eventFilter = new HashSet();
+ eventFilter.add(MouseEvent.MOUSE_PRESSED);
+ eventFilter.add(MouseEvent.MOUSE_RELEASED);
+ eventFilter.add(FocusEvent.FOCUS_GAINED);
+ }
+
+ /**
+ *
+ * Returns the collection of event sequences that is obtained from parsing
+ * log files.
+ *
+ *
+ * @return collection of event sequences
+ */
+ public Collection> 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)
+ */
+ public void startElement(String uri, String localName, String qName,
+ Attributes atts) throws SAXException {
+ if (qName.equals("sessions")) {
+ currentSequence = new LinkedList();
+ }
+ if (qName.equals("newsession")) {
+ Console.traceln("start of session");
+ if (currentSequence != null && !currentSequence.isEmpty()) {
+ sequences.add(currentSequence);
+ }
+ currentSequence = new LinkedList();
+ } else if (qName.equals("event")) {
+ int eventId = Integer.parseInt(atts.getValue("id"));
+ if ((eventFilter == null) || (!eventFilter.contains(eventId))) {
+ currentEvent = new JFCEvent(atts.getValue("id"));
+ paramSource = ParamSource.EVENT;
+ }
+ } else if (currentEvent != null) {
+ if (qName.equals("param")) {
+ if (paramSource == ParamSource.EVENT) {
+ currentEvent.addParameter(atts.getValue("name"),
+ atts.getValue("value"));
+ } else if (paramSource == ParamSource.SOURCE) {
+ currentEvent.addSourceInformation(atts.getValue("name"),
+ atts.getValue("value"));
+ } else if (paramSource == ParamSource.PARENT) {
+ currentEvent.addParentInformation(atts.getValue("name"),
+ atts.getValue("value"));
+ } else if (paramSource == ParamSource.COMPONENT) {
+ componentString += "'" + atts.getValue("value") + "',";
+ }
+ } else if (qName.equals("source")) {
+ paramSource = ParamSource.SOURCE;
+ } else if (qName.equals("parent")) {
+ paramSource = ParamSource.PARENT;
+ } else if (qName.equals("component")) {
+ paramSource = ParamSource.COMPONENT;
+ componentString = "[";
+ }
+ }
+ }
+
+ /*
+ * (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("sessions")) {
+ if (currentSequence != null && !currentSequence.isEmpty()) {
+ sequences.add(currentSequence);
+ }
+ currentSequence = null;
+ } else if (currentEvent != null) {
+ if (qName.equals("event")) {
+ currentSequence.add(currentEvent);
+ currentEvent = null;
+ } else if (qName.equals("source")) {
+ paramSource = ParamSource.EVENT;
+ } else if (qName.equals("parent")) {
+ paramSource = ParamSource.SOURCE;
+ } else if (qName.equals("component")) {
+ paramSource.equals(ParamSource.SOURCE);
+ currentEvent.extendTarget(componentString.substring(0,
+ componentString.length() - 1) + "]");
+ }
+ }
+ }
+
+ /**
+ *
+ * Parses a log file written by the JFCMonitor and creates a collection of
+ * event sequences.
+ *
+ *
+ * @param filename
+ * name and path of the log file
+ */
+ public void parseFile(String filename) {
+ 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-8"));
+ } catch (UnsupportedEncodingException e) {
+ e.printStackTrace();
+ } catch (ParserConfigurationException e) {
+ e.printStackTrace();
+ } catch (SAXException e) {
+ e.printStackTrace();
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ }
+ 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 (SAXException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+}
Index: /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/jfc/commands/CMDparseDirJFC.java
===================================================================
--- /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/jfc/commands/CMDparseDirJFC.java (revision 426)
+++ /tags/eventbench-pre-quest-conversion/EventBenchConsole/src/de/ugoe/cs/eventbench/jfc/commands/CMDparseDirJFC.java (revision 426)
@@ -0,0 +1,92 @@
+package de.ugoe.cs.eventbench.jfc.commands;
+
+import java.io.File;
+import java.security.InvalidParameterException;
+import java.util.Collection;
+import java.util.List;
+
+import de.ugoe.cs.eventbench.CommandHelpers;
+import de.ugoe.cs.eventbench.data.GlobalDataContainer;
+import de.ugoe.cs.eventbench.jfc.JFCLogParser;
+import de.ugoe.cs.eventbench.jfc.data.JFCEvent;
+import de.ugoe.cs.eventbench.jfc.data.JFCTargetComparator;
+import de.ugoe.cs.util.console.Command;
+import de.ugoe.cs.util.console.Console;
+
+/**
+ *
+ * Command that tries to parse all files in a folder as if they were log files
+ * generated by the JFCMonitor. The result is one set of sequences for all files
+ * (not one set of sequences for each file!).
+ *
+ *
+ * @author Steffen Herbold
+ * @version 1.0
+ */
+public class CMDparseDirJFC implements Command {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.util.console.Command#run(java.util.List)
+ */
+ @Override
+ public void run(List parameters) {
+ String path;
+ String sequencesName = "sequences";
+
+ try {
+ path = (String) parameters.get(0);
+ if (parameters.size() >= 2) {
+ sequencesName = (String) parameters.get(1);
+ }
+ } catch (Exception e) {
+ throw new InvalidParameterException();
+ }
+
+ File folder = new File(path);
+ if (!folder.isDirectory()) {
+ Console.printerrln(path + " is not a directory");
+ return;
+ }
+
+ JFCTargetComparator.setMutable(true);
+ JFCLogParser parser = new JFCLogParser();
+
+ String absolutPath = folder.getAbsolutePath();
+ for (String filename : folder.list()) {
+ String source = absolutPath + "/" + filename;
+ Console.traceln("Processing file: " + source);
+
+ parser.parseFile(source);
+ }
+
+ Collection> sequences = parser.getSequences();
+ Console.traceln("Pre-computing event target equalities.");
+ // compare all Events to a dummy event to make sure they are known by
+ // the JFCTargetComparator
+ JFCEvent dummyEvent = new JFCEvent("dummy");
+ for (List sequence : sequences) {
+ for (JFCEvent event : sequence) {
+ event.equals(dummyEvent);
+ }
+ }
+ JFCTargetComparator.setMutable(false);
+
+ if (GlobalDataContainer.getInstance().addData(sequencesName, sequences)) {
+ CommandHelpers.dataOverwritten(sequencesName);
+ }
+
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see de.ugoe.cs.util.console.Command#help()
+ */
+ @Override
+ public void help() {
+ Console.println("Usage: parseDirJFC {