defect = rule.callEvaluationMethod(evaluationMethodCaller);
if(defect.isPresent()) {
result.addDefect(defect.get());
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityMetric.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityMetric.java (revision 1149)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityMetric.java (revision 1150)
@@ -15,4 +15,8 @@
package de.ugoe.cs.autoquest.usability.rules;
+import com.google.common.base.Optional;
+
+import de.ugoe.cs.autoquest.usability.result.UsabilityDefect;
+
/**
*
@@ -23,4 +27,6 @@
*/
public interface UsabilityMetric {
+
+ public Optional calculate();
}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityRule.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityRule.java (revision 1149)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityRule.java (revision 1150)
@@ -18,4 +18,5 @@
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.usability.EvaluationMethodCaller;
import de.ugoe.cs.autoquest.usability.result.UsabilityDefect;
@@ -45,5 +46,5 @@
}
- public abstract Optional check();
+ public abstract Optional callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller);
}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityUsageDefect.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityUsageDefect.java (revision 1150)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/UsabilityUsageDefect.java (revision 1150)
@@ -0,0 +1,32 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules;
+
+import com.google.common.base.Optional;
+
+import de.ugoe.cs.autoquest.usability.result.UsabilityDefect;
+
+/**
+ *
+ * TODO comment
+ *
+ *
+ * @author Alexander Deicke
+ */
+public interface UsabilityUsageDefect {
+
+ public Optional check();
+
+}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/NoLetterOrDigitRatioMetric.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/NoLetterOrDigitRatioMetric.java (revision 1149)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/NoLetterOrDigitRatioMetric.java (revision 1150)
@@ -27,4 +27,5 @@
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.usability.EvaluationMethodCaller;
import de.ugoe.cs.autoquest.usability.result.DefectDescriptionResolver;
import de.ugoe.cs.autoquest.usability.result.UsabilityDefect;
@@ -61,5 +62,5 @@
*/
@Override
- public Optional check() {
+ public Optional calculate() {
FilterResult textInputEvents = extractNodesFromTaskTree();
float evaluationMetric = calculateEvaluationMetric(textInputEvents.nodesMatchedFilter());
@@ -88,3 +89,12 @@
}
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#callEvaluationMetho(de.ugoe.cs.autoquest.usability.EvaluationMethodCaller)
+ */
+ @Override
+ public Optional callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller)
+ {
+ return evaluationMethodCaller.check(this);
+ }
+
}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/TextInputEntryRepetitionsMetric.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/TextInputEntryRepetitionsMetric.java (revision 1149)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/TextInputEntryRepetitionsMetric.java (revision 1150)
@@ -27,4 +27,5 @@
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.usability.EvaluationMethodCaller;
import de.ugoe.cs.autoquest.usability.result.DefectDescriptionResolver;
import de.ugoe.cs.autoquest.usability.result.UsabilityDefect;
@@ -61,5 +62,5 @@
*/
@Override
- public Optional check() {
+ public Optional calculate() {
FilterResult textInputEvents = extractNodesFromTaskTree();
float evaluationMetric = calculateEvaluationMetric(textInputEvents.nodesMatchedFilter());
@@ -103,3 +104,12 @@
}
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#callEvaluationMetho(de.ugoe.cs.autoquest.usability.EvaluationMethodCaller)
+ */
+ @Override
+ public Optional callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller)
+ {
+ return evaluationMethodCaller.check(this);
+ }
+
}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/TextInputRatioMetric.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/TextInputRatioMetric.java (revision 1149)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/metrics/TextInputRatioMetric.java (revision 1150)
@@ -25,4 +25,5 @@
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.usability.EvaluationMethodCaller;
import de.ugoe.cs.autoquest.usability.result.DefectDescriptionResolver;
import de.ugoe.cs.autoquest.usability.result.UsabilityDefect;
@@ -59,5 +60,5 @@
*/
@Override
- public Optional check() {
+ public Optional calculate() {
FilterResult textInputEvents = extractNodesFromTaskTree();
float evaluationMetric = calculateEvaluationMetric(textInputEvents.nodesMatchedFilter(), textInputEvents.nodesNotMatchedFilter());
@@ -88,3 +89,11 @@
}
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#callEvaluationMetho(de.ugoe.cs.autoquest.usability.EvaluationMethodCaller)
+ */
+ @Override
+ public Optional callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller)
+ {
+ return evaluationMethodCaller.check(this);
+ }
}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/LongFormUsageDefect.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/LongFormUsageDefect.java (revision 1150)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/LongFormUsageDefect.java (revision 1150)
@@ -0,0 +1,89 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns;
+
+import static de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter.MOUSE_CLICK;
+import static de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter.SCROLL;
+import static de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter.TEXT_INPUT;
+import static de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTreeNodeTypeFilter.ITERATION;
+import static de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTreeNodeTypeFilter.SEQUENCE;
+
+import com.google.common.base.Optional;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.usability.EvaluationMethodCaller;
+import de.ugoe.cs.autoquest.usability.result.DefectDescriptionResolver;
+import de.ugoe.cs.autoquest.usability.result.UsabilityDefect;
+import de.ugoe.cs.autoquest.usability.rules.UsabilityRule;
+import de.ugoe.cs.autoquest.usability.rules.UsabilityUsageDefect;
+
+/**
+ *
+ * TODO comment
+ *
+ *
+ * @author Alexander Deicke
+ */
+public class LongFormUsageDefect extends UsabilityRule implements UsabilityUsageDefect {
+
+ private UsagePattern longFormUsagePattern;
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param taskTree
+ */
+ public LongFormUsageDefect(ITaskTree taskTree) {
+ super(taskTree);
+ this.name = "LongFormUsagePattern";
+ this.defect = new DefectDescriptionResolver().descriptionFor(this.getClass().getSimpleName());
+ initUsagePattern();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ */
+ private void initUsagePattern() {
+ UsagePatternBuilder builder = new UsagePatternBuilder();
+ UsagePattern fillFormPattern = builder.concernedNode(ITERATION).startsWith(TEXT_INPUT).endsWith(SCROLL).build();
+ this.longFormUsagePattern = builder.concernedNode(SEQUENCE).startsWith(MOUSE_CLICK).contains(fillFormPattern).endsWith(MOUSE_CLICK).build();
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#check()
+ */
+ @Override
+ public Optional check() {
+ Optional present = Optional.absent();
+ if(this.longFormUsagePattern.containedIn(taskTree)) {
+ present = Optional.of(this.defect);
+ }
+ return present;
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.usability.rules.UsabilityRule#callEvaluationMetho(de.ugoe.cs.autoquest.usability.EvaluationMethodCaller)
+ */
+ @Override
+ public Optional callEvaluationMethod(EvaluationMethodCaller evaluationMethodCaller)
+ {
+ return evaluationMethodCaller.check(this);
+ }
+}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePattern.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePattern.java (revision 1150)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePattern.java (revision 1150)
@@ -0,0 +1,138 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns;
+
+import java.util.Arrays;
+import java.util.List;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Predicate;
+import com.google.common.collect.Iterables;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.usability.tasktree.IterativeDFSFilterStrategy;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTreeFilter;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTreeNodeTypeFilter;
+
+/**
+ *
+ * TODO comment
+ *
+ *
+ * @author Alexander Deicke
+ */
+public class UsagePattern {
+
+ private TaskTreeFilter taskTreeFilter = new TaskTreeFilter(new IterativeDFSFilterStrategy());
+
+ private TaskTreeNodeTypeFilter concernedNode;
+
+ private List patternVisitors;
+
+ private boolean present = false;
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param concernedNode
+ * @param eventType
+ */
+ public UsagePattern(TaskTreeNodeTypeFilter concernedNode,
+ UsagePatternVisitor... patternVisitor)
+ {
+ this.patternVisitors = Arrays.asList(patternVisitor);
+ this.concernedNode = concernedNode;
+ }
+
+ public boolean containedIn(ITaskTree taskTree) {
+ List allConcernedNodes = filterAllConcernedNodeFrom(taskTree);
+ for(ITaskTreeNode concernedNode : allConcernedNodes) {
+ applyAllVisitors(concernedNode);
+ if(allVisitorsArePresent()) {
+ this.present = true;
+ break;
+ } else {
+ resetAllVisitors();
+ }
+
+ }
+ return this.present;
+ }
+
+ private void applyAllVisitors(ITaskTreeNode concernedNode) {
+ Optional previousVisitor = Optional.absent();
+ for(UsagePatternVisitor visitor : patternVisitors) {
+ if(appliedOnSelectionNode(previousVisitor)) {
+ for(ITaskTreeNode selectionNode : previousVisitor.get().getRetainedSelectionNodes()) {
+ selectionNode.accept(visitor);
+ }
+ } else {
+ previousVisitor = Optional.of(visitor);
+ concernedNode.accept(visitor);
+ }
+ }
+ }
+
+ private boolean appliedOnSelectionNode(Optional previousVisitor) {
+ return previousVisitor.isPresent() && previousVisitor.get().hasExcludedSelectionNodes();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param taskTree
+ * @return
+ */
+ private List filterAllConcernedNodeFrom(ITaskTree taskTree) {
+ return this.taskTreeFilter.filterByNodeType(this.concernedNode).from(taskTree).nodesMatchedFilter();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ private boolean allVisitorsArePresent() {
+ Iterable allPresent = Iterables.filter(this.patternVisitors, new Predicate() {
+
+ public boolean apply(UsagePatternVisitor visitor) {
+ return visitor.isPresent();
+ }
+
+ });
+ return Iterables.size(allPresent) == this.patternVisitors.size();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ */
+ private void resetAllVisitors() {
+ for(UsagePatternVisitor visitor : this.patternVisitors) {
+ visitor.reset();
+ }
+
+ }
+
+}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePatternBuilder.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePatternBuilder.java (revision 1150)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePatternBuilder.java (revision 1150)
@@ -0,0 +1,710 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns;
+
+import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.ContainsEventVisitor;
+import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.ContainsPatternVisitor;
+import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.EndsWithEventVisitor;
+import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.EndsWithPatternVisitor;
+import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.StartsWithEventVisitor;
+import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.StartsWithPatternVisitor;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTreeNodeTypeFilter;
+
+/**
+ *
+ * TODO comment
+ *
+ *
+ * @author Alexander Deicke
+ */
+public class UsagePatternBuilder {
+
+ protected TaskTreeNodeTypeFilter concernedNode;
+
+ protected EventTypeFilter startsWithEvent;
+
+ protected UsagePattern startsWithPattern;
+
+ protected EventTypeFilter endsWithEvent;
+
+ protected UsagePattern endsWithPattern;
+
+ protected EventTypeFilter containsEvent;
+
+ protected UsagePattern containsPattern;
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param sequence
+ * @return
+ */
+ public SpecifyPatternStep concernedNode(TaskTreeNodeTypeFilter concernedNode) {
+ this.concernedNode = concernedNode;
+ return new SpecifyPatternStep();
+ }
+
+ public class SpecifyPatternStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param textInput
+ * @return
+ */
+ public BuildStartsWithEventStep startsWith(EventTypeFilter startsWithType) {
+ UsagePatternBuilder.this.startsWithEvent = startsWithType;
+ return new BuildStartsWithEventStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param startsWithPattern
+ * @return
+ */
+ public BuildStartsWithPatternStep startsWith(UsagePattern startsWithPattern) {
+ UsagePatternBuilder.this.startsWithPattern = startsWithPattern;
+ return new BuildStartsWithPatternStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param textInput
+ * @return
+ */
+ public BuildEndsWithEventStep endsWith(EventTypeFilter endsWithType) {
+ UsagePatternBuilder.this.endsWithEvent = endsWithType;
+ return new BuildEndsWithEventStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param endsWithPattern
+ * @return
+ */
+ public BuildEndsWithPatternStep endsWith(UsagePattern endsWithPattern) {
+ UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
+ return new BuildEndsWithPatternStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param textInput
+ * @return
+ */
+ public BuildContainsEventStep contains(EventTypeFilter containsType) {
+ UsagePatternBuilder.this.containsEvent = containsType;
+ return new BuildContainsEventStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param containsPattern
+ * @return
+ */
+ public BuildContainsPatternStep contains(UsagePattern containsPattern) {
+ UsagePatternBuilder.this.containsPattern = containsPattern;
+ return new BuildContainsPatternStep();
+ }
+
+ }
+
+ public class BuildStartsWithEventStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param endsWithType
+ * @return
+ */
+ public BuildStartsAndEndsWithEventStep endsWith(EventTypeFilter endsWithType) {
+ UsagePatternBuilder.this.endsWithEvent = endsWithType;
+ return new BuildStartsAndEndsWithEventStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param endsWithPattern
+ * @return
+ */
+ public BuildStartsWithEventAndEndsWithPattern endsWith(UsagePattern endsWithPattern) {
+ UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
+ return new BuildStartsWithEventAndEndsWithPattern();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param textInput
+ * @return
+ */
+ public BuildStartsWithEventAndContainsEventStep contains(EventTypeFilter containsType) {
+ UsagePatternBuilder.this.containsEvent = containsType;
+ return new BuildStartsWithEventAndContainsEventStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param containedPattern
+ * @return
+ */
+ public BuildStartsWithEventAndContainsPatternStep contains(UsagePattern containsPattern) {
+ UsagePatternBuilder.this.containsPattern = containsPattern;
+ return new BuildStartsWithEventAndContainsPatternStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent));
+ }
+
+ }
+
+ public class BuildStartsWithPatternStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param containsEvent
+ * @return
+ */
+ public BuildStartsWithPatternAndContainsEventStep contains(EventTypeFilter containsEvent) {
+ UsagePatternBuilder.this.containsEvent = containsEvent;
+ return new BuildStartsWithPatternAndContainsEventStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param containedPattern
+ * @return
+ */
+ public BuildStartsWithPatternAndContainsPatternStep contains(UsagePattern containsPattern) {
+ UsagePatternBuilder.this.containsPattern = containsPattern;
+ return new BuildStartsWithPatternAndContainsPatternStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param textInput
+ * @return
+ */
+ public BuildStartsWithPatternAndEndsWithEventStep endsWith(EventTypeFilter endsWithEvent) {
+ UsagePatternBuilder.this.endsWithEvent = endsWithEvent;
+ return new BuildStartsWithPatternAndEndsWithEventStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param endsWithPattern
+ * @return
+ */
+ public BuildStartsAndEndsWithPatternStep endsWith(UsagePattern endsWithPattern) {
+ UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
+ return new BuildStartsAndEndsWithPatternStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern));
+ }
+
+ }
+
+ public class BuildEndsWithEventStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new EndsWithEventVisitor(endsWithEvent));
+ }
+
+ }
+
+ public class BuildEndsWithPatternStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new EndsWithPatternVisitor(endsWithPattern));
+ }
+
+ }
+
+ public class BuildContainsEventStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param textInput
+ * @return
+ */
+ public BuildContainsAndEndsWithEventStep endsWith(EventTypeFilter endsWithType) {
+ UsagePatternBuilder.this.endsWithEvent = endsWithType;
+ return new BuildContainsAndEndsWithEventStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new ContainsEventVisitor(containsEvent));
+ }
+
+ }
+
+ public class BuildContainsPatternStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new ContainsPatternVisitor(containsPattern));
+ }
+
+ }
+
+ public class BuildStartsAndEndsWithEventStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new EndsWithEventVisitor(endsWithEvent));
+ }
+
+ }
+
+ public class BuildStartsWithEventAndEndsWithPattern {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new EndsWithPatternVisitor(endsWithPattern));
+ }
+
+ }
+
+ public class BuildStartsWithPatternAndEndsWithEventStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new EndsWithEventVisitor(endsWithEvent));
+ }
+
+ }
+
+ public class BuildStartsAndEndsWithPatternStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new EndsWithPatternVisitor(endsWithPattern));
+ }
+
+ }
+
+ public class BuildStartsWithEventAndContainsEventStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param textInput
+ * @return
+ */
+ public BuildStartsAndEndsWithEventAndContainsEventStep endsWith(EventTypeFilter endsWithEvent) {
+ UsagePatternBuilder.this.endsWithEvent = endsWithEvent;
+ return new BuildStartsAndEndsWithEventAndContainsEventStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param endsWithPattern
+ * @return
+ */
+ public BuildStartsWithEventContainsEventAndEndsWithPatternStep endsWith(UsagePattern endsWithPattern) {
+ UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
+ return new BuildStartsWithEventContainsEventAndEndsWithPatternStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new ContainsEventVisitor(containsEvent));
+ }
+
+ }
+
+ public class BuildStartsWithPatternAndContainsPatternStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param textInput
+ * @return
+ */
+ public BuildStartsContainsPatternAndEndsWithEventStep endsWith(EventTypeFilter endsWithEvent) {
+ UsagePatternBuilder.this.endsWithEvent = endsWithEvent;
+ return new BuildStartsContainsPatternAndEndsWithEventStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param endsWithPattern
+ * @return
+ */
+ public BuildStartsAndEndsWithPatternAndContainsPatternStep endsWith(UsagePattern endsWithPattern) {
+ UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
+ return new BuildStartsAndEndsWithPatternAndContainsPatternStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new ContainsPatternVisitor(containsPattern));
+ }
+
+ }
+
+ public class BuildStartsWithEventAndContainsPatternStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param textInput
+ * @return
+ */
+ public BuildStartsWithEventContainsPatternAndEndsWithEventStep endsWith(EventTypeFilter endsWithEvent) {
+ UsagePatternBuilder.this.endsWithEvent = endsWithEvent;
+ return new BuildStartsWithEventContainsPatternAndEndsWithEventStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param endsWithPattern
+ * @return
+ */
+ public BuildStartsWithEventContainsPatternAndEndsWithPatternStep endsWith(UsagePattern endsWithPattern) {
+ UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
+ return new BuildStartsWithEventContainsPatternAndEndsWithPatternStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new ContainsPatternVisitor(containsPattern));
+ }
+
+ }
+
+ public class BuildStartsWithPatternAndContainsEventStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param textInput
+ * @return
+ */
+ public BuildStartsWithPatternContainsEventAndEndsWithEventStep endsWith(EventTypeFilter endsWithEvent) {
+ UsagePatternBuilder.this.endsWithEvent = endsWithEvent;
+ return new BuildStartsWithPatternContainsEventAndEndsWithEventStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param endsWithPattern
+ * @return
+ */
+ public BuildStartsWithPatternContainsEventAndEndsWithPatternStep endsWith(UsagePattern endsWithPattern) {
+ UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
+ return new BuildStartsWithPatternContainsEventAndEndsWithPatternStep();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new ContainsEventVisitor(containsEvent));
+ }
+
+ }
+
+ public class BuildStartsAndEndsWithEventAndContainsEventStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new EndsWithEventVisitor(endsWithEvent), new ContainsEventVisitor(containsEvent));
+ }
+
+ }
+
+ public class BuildStartsContainsPatternAndEndsWithEventStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new ContainsPatternVisitor(containsPattern), new EndsWithEventVisitor(endsWithEvent));
+ }
+
+ }
+
+ public class BuildStartsAndEndsWithPatternAndContainsPatternStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new EndsWithPatternVisitor(endsWithPattern), new ContainsPatternVisitor(containsPattern));
+ }
+
+ }
+
+ public class BuildStartsWithEventContainsEventAndEndsWithPatternStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new ContainsEventVisitor(containsEvent), new EndsWithPatternVisitor(endsWithPattern));
+ }
+
+ }
+
+ public class BuildStartsWithEventContainsPatternAndEndsWithEventStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new ContainsPatternVisitor(containsPattern), new EndsWithEventVisitor(endsWithEvent));
+ }
+
+ }
+
+ public class BuildStartsWithEventContainsPatternAndEndsWithPatternStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new ContainsPatternVisitor(containsPattern), new EndsWithPatternVisitor(endsWithPattern));
+ }
+
+ }
+
+ public class BuildStartsWithPatternContainsEventAndEndsWithEventStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new ContainsEventVisitor(containsEvent), new EndsWithEventVisitor(endsWithEvent));
+ }
+
+ }
+
+ public class BuildStartsWithPatternContainsEventAndEndsWithPatternStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new ContainsEventVisitor(containsEvent), new EndsWithPatternVisitor(endsWithPattern));
+ }
+
+ }
+
+ public class BuildContainsAndEndsWithEventStep {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public UsagePattern build() {
+ return new UsagePattern(concernedNode, new ContainsEventVisitor(containsEvent), new EndsWithEventVisitor(endsWithEvent));
+ }
+
+ }
+
+}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePatternVisitor.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePatternVisitor.java (revision 1150)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePatternVisitor.java (revision 1150)
@@ -0,0 +1,150 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns;
+
+import java.util.List;
+
+import org.apache.commons.lang.StringUtils;
+
+import com.google.common.base.Splitter;
+import com.google.common.collect.Lists;
+
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+import de.ugoe.cs.autoquest.eventcore.StringEventType;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter;
+import de.ugoe.cs.autoquest.usability.util.PatternsVisitorUtil;
+
+/**
+ *
+ * TODO comment
+ *
+ *
+ * @author Alexander Deicke
+ */
+public abstract class UsagePatternVisitor implements NodeVisitor {
+
+ protected EventTypeFilter eventType;
+
+ protected UsagePattern containedPattern;
+
+ protected boolean present = false;
+
+ protected List retainedChildrenNodesFromSelectionNodes = Lists.newArrayList();
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask)
+ */
+ public void visit(IEventTask event) {
+ if(!this.present && isEventVisitor()) {
+ IEventType eventType = event.getEventType();
+ if(eventType instanceof StringEventType) {
+ this.present = eventType.toString().equals(nameOfEventType());
+ } else {
+ this.present = eventType.getClass().equals(this.eventType.clazz());
+ }
+ }
+ }
+
+ public boolean isEventVisitor() {
+ return this.eventType != null && this.containedPattern == null;
+ }
+
+ protected String nameOfEventType() {
+ String ret = StringUtils.EMPTY;
+ Iterable splitted = Splitter.on("_").split(this.eventType.name());
+ for(String str : splitted) {
+ str = str.toLowerCase();
+ ret += Character.toString(str.charAt(0)).toUpperCase() + str.substring(1);
+ }
+ return ret;
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection)
+ */
+ public void visit(ISelection selection) {
+ if(isEventVisitor()) {
+ retainNodesWherePatternIsPresent(selection.getChildren());
+ this.present = patternIsPresent();
+ } else {
+ ITaskTree taskTree = PatternsVisitorUtil.createTaskTreeFromNode(selection);
+ this.present = containedPattern.containedIn(taskTree);
+ }
+ }
+
+ protected void retainNodesWherePatternIsPresent(List children) {
+ for(ITaskTreeNode node : children) {
+ this.present = false;
+ node.accept(this);
+ if(this.present) {
+ this.retainedChildrenNodesFromSelectionNodes.add(node);
+ }
+ }
+ }
+
+ private boolean patternIsPresent() {
+ return !this.retainedChildrenNodesFromSelectionNodes.isEmpty();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public boolean isPresent() {
+ return this.present;
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ */
+ public void reset() {
+ this.retainedChildrenNodesFromSelectionNodes.clear();
+ this.present = false;
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public boolean hasExcludedSelectionNodes() {
+ return patternIsPresent();
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @return
+ */
+ public List getRetainedSelectionNodes() {
+ return this.retainedChildrenNodesFromSelectionNodes;
+ }
+
+}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/ContainsEventVisitor.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/ContainsEventVisitor.java (revision 1150)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/ContainsEventVisitor.java (revision 1150)
@@ -0,0 +1,68 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns.visitors;
+
+import java.util.List;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternVisitor;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter;
+
+/**
+ *
+ * TODO comment
+ *
+ *
+ * @author Alexander Deicke
+ */
+public class ContainsEventVisitor extends UsagePatternVisitor {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param containsType
+ */
+ public ContainsEventVisitor(EventTypeFilter containsType) {
+ this.eventType = containsType;
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration)
+ */
+ public void visit(IIteration iteration) {
+ checkAllChildrenAndReturnIfPatternIsPresent(iteration.getChildren());
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence)
+ */
+ public void visit(ISequence sequence) {
+ checkAllChildrenAndReturnIfPatternIsPresent(sequence.getChildren());
+ }
+
+ private void checkAllChildrenAndReturnIfPatternIsPresent(List children) {
+ for(ITaskTreeNode node : children) {
+ node.accept(this);
+ if(this.present) {
+ break;
+ }
+ }
+ }
+
+}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/ContainsPatternVisitor.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/ContainsPatternVisitor.java (revision 1150)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/ContainsPatternVisitor.java (revision 1150)
@@ -0,0 +1,80 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns.visitors;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePattern;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternVisitor;
+import de.ugoe.cs.autoquest.usability.util.PatternsVisitorUtil;
+
+/**
+ *
+ * TODO comment
+ *
+ *
+ * @author Alexander Deicke
+ */
+public class ContainsPatternVisitor extends UsagePatternVisitor {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param containsPattern
+ */
+ public ContainsPatternVisitor(UsagePattern containsPattern) {
+ this.containedPattern = containsPattern;
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration)
+ */
+ public void visit(IIteration iteration) {
+ checkAllChildrenAndReturnIfPatternIsPresent(iteration);
+
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence)
+ */
+ public void visit(ISequence sequence) {
+ checkAllChildrenAndReturnIfPatternIsPresent(sequence);
+
+ }
+
+ private void checkAllChildrenAndReturnIfPatternIsPresent(ITaskTreeNode node) {
+ for(ITaskTreeNode child : node.getChildren()) {
+ ITaskTree taskTree;
+ if(isEvent(child)) {
+ taskTree = PatternsVisitorUtil.createTaskTreeFromNode(node);
+ } else {
+ taskTree = PatternsVisitorUtil.createTaskTreeFromNode(child);
+ }
+ this.present = containedPattern.containedIn(taskTree);
+ if(this.present) {
+ break;
+ }
+ }
+ }
+
+ private boolean isEvent(ITaskTreeNode firstNode) {
+ return firstNode.getChildren().isEmpty();
+ }
+
+}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/EndsWithEventVisitor.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/EndsWithEventVisitor.java (revision 1150)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/EndsWithEventVisitor.java (revision 1150)
@@ -0,0 +1,57 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns.visitors;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternVisitor;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter;
+import de.ugoe.cs.autoquest.usability.util.PatternsVisitorUtil;
+
+/**
+ *
+ * TODO comment
+ *
+ *
+ * @author Alexander Deicke
+ */
+public class EndsWithEventVisitor extends UsagePatternVisitor {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param eventType
+ */
+ public EndsWithEventVisitor(EventTypeFilter eventType) {
+ this.eventType = eventType;
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration)
+ */
+ public void visit(IIteration iteration) {
+ PatternsVisitorUtil.lastNodeOf(iteration.getChildren()).accept(this);
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence)
+ */
+ public void visit(ISequence sequence) {
+ PatternsVisitorUtil.lastNodeOf(sequence.getChildren()).accept(this);
+ }
+
+}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/EndsWithPatternVisitor.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/EndsWithPatternVisitor.java (revision 1150)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/EndsWithPatternVisitor.java (revision 1150)
@@ -0,0 +1,72 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns.visitors;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePattern;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternVisitor;
+import de.ugoe.cs.autoquest.usability.util.PatternsVisitorUtil;
+
+/**
+ *
+ * TODO comment
+ *
+ *
+ * @author Alexander Deicke
+ */
+public class EndsWithPatternVisitor extends UsagePatternVisitor {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param endsWithPattern
+ */
+ public EndsWithPatternVisitor(UsagePattern endsWithPattern) {
+ this.containedPattern = endsWithPattern;
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration)
+ */
+ public void visit(IIteration iteration) {
+ ITaskTree taskTree = PatternsVisitorUtil.createTaskTreeFromNode(iteration);
+ this.present = containedPattern.containedIn(taskTree);
+
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence)
+ */
+ public void visit(ISequence sequence) {
+ ITaskTreeNode lastNode = PatternsVisitorUtil.lastNodeOf(sequence.getChildren());
+ ITaskTree taskTree;
+ if(isEvent(lastNode)) {
+ taskTree = PatternsVisitorUtil.createTaskTreeFromNode(sequence);
+ } else {
+ taskTree = PatternsVisitorUtil.createTaskTreeFromNode(lastNode);
+ }
+ this.present = containedPattern.containedIn(taskTree);
+ }
+
+ private boolean isEvent(ITaskTreeNode firstNode) {
+ return firstNode.getChildren().isEmpty();
+ }
+
+}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/StartsWithEventVisitor.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/StartsWithEventVisitor.java (revision 1150)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/StartsWithEventVisitor.java (revision 1150)
@@ -0,0 +1,57 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns.visitors;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternVisitor;
+import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter;
+import de.ugoe.cs.autoquest.usability.util.PatternsVisitorUtil;
+
+/**
+ *
+ * TODO comment
+ *
+ *
+ * @author Alexander Deicke
+ */
+public class StartsWithEventVisitor extends UsagePatternVisitor {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param eventType
+ */
+ public StartsWithEventVisitor(EventTypeFilter eventType) {
+ this.eventType = eventType;
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration)
+ */
+ public void visit(IIteration iteration) {
+ PatternsVisitorUtil.firstNodeOf(iteration.getChildren()).accept(this);
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence)
+ */
+ public void visit(ISequence sequence) {
+ PatternsVisitorUtil.firstNodeOf(sequence.getChildren()).accept(this);
+ }
+
+}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/StartsWithPatternVisitor.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/StartsWithPatternVisitor.java (revision 1150)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/visitors/StartsWithPatternVisitor.java (revision 1150)
@@ -0,0 +1,71 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.rules.patterns.visitors;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePattern;
+import de.ugoe.cs.autoquest.usability.rules.patterns.UsagePatternVisitor;
+import de.ugoe.cs.autoquest.usability.util.PatternsVisitorUtil;
+
+/**
+ *
+ * TODO comment
+ *
+ *
+ * @author Alexander Deicke
+ */
+public class StartsWithPatternVisitor extends UsagePatternVisitor {
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param startsWithPattern
+ */
+ public StartsWithPatternVisitor(UsagePattern startsWithPattern) {
+ this.containedPattern = startsWithPattern;
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration)
+ */
+ public void visit(IIteration iteration) {
+ ITaskTree taskTree = PatternsVisitorUtil.createTaskTreeFromNode(iteration);
+ this.present = containedPattern.containedIn(taskTree);
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor#visit(de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence)
+ */
+ public void visit(ISequence sequence) {
+ ITaskTreeNode firstNode = PatternsVisitorUtil.firstNodeOf(sequence.getChildren());
+ ITaskTree taskTree;
+ if(isEvent(firstNode)) {
+ taskTree = PatternsVisitorUtil.createTaskTreeFromNode(sequence);
+ } else {
+ taskTree = PatternsVisitorUtil.createTaskTreeFromNode(firstNode);
+ }
+ this.present = containedPattern.containedIn(taskTree);
+ }
+
+ private boolean isEvent(ITaskTreeNode firstNode) {
+ return firstNode.getChildren().isEmpty();
+ }
+
+}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/tasktree/filters/EventTypeFilter.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/tasktree/filters/EventTypeFilter.java (revision 1149)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/tasktree/filters/EventTypeFilter.java (revision 1150)
@@ -22,5 +22,7 @@
import de.ugoe.cs.autoquest.eventcore.gui.IInteraction;
import de.ugoe.cs.autoquest.eventcore.gui.MouseButtonInteraction;
+import de.ugoe.cs.autoquest.eventcore.gui.MouseClick;
import de.ugoe.cs.autoquest.eventcore.gui.MouseInteraction;
+import de.ugoe.cs.autoquest.eventcore.gui.Scroll;
import de.ugoe.cs.autoquest.eventcore.gui.TextInput;
import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
@@ -38,7 +40,11 @@
MOUSE_BUTTON_INTERACTION(MouseButtonInteraction.class),
+ MOUSE_CLICK(MouseClick.class),
+
MOUSE_INTERACTION(MouseInteraction.class),
TEXT_INPUT(TextInput.class),
+
+ SCROLL(Scroll.class),
USER_INTERACTION(IInteraction.class);
@@ -49,5 +55,5 @@
this.eventTypeClazz = eventTypeClazz;
}
-
+
@SuppressWarnings("unchecked")
@Override
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/tasktree/filters/TaskTreeNodeTypeFilter.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/tasktree/filters/TaskTreeNodeTypeFilter.java (revision 1149)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/tasktree/filters/TaskTreeNodeTypeFilter.java (revision 1150)
@@ -19,4 +19,7 @@
import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
@@ -30,5 +33,11 @@
public enum TaskTreeNodeTypeFilter implements TaskTreeNodeFilter {
- EVENT_TASK_NODE(IEventTask.class);
+ EVENT_TASK_NODE(IEventTask.class),
+
+ ITERATION(IIteration.class),
+
+ SEQUENCE(ISequence.class),
+
+ SELECTION(ISelection.class),;
private Class nodeTypeClazz;
@@ -47,5 +56,5 @@
@Override
public Predicate filterPredicate() {
- return Predicates.instanceOf(IEventTask.class);
+ return Predicates.instanceOf(nodeTypeClazz);
}
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/util/NullNode.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/util/NullNode.java (revision 1150)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/util/NullNode.java (revision 1150)
@@ -0,0 +1,78 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.util;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.commons.lang.StringUtils;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor;
+
+/**
+ *
+ * TODO comment
+ *
+ *
+ * @author Alexander Deicke
+ */
+public class NullNode implements ITaskTreeNode {
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode#getName()
+ */
+ public String getName() {
+ return StringUtils.EMPTY;
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode#getDescription()
+ */
+ public String getDescription() {
+ return StringUtils.EMPTY;
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode#getChildren()
+ */
+ public List getChildren() {
+ return Collections.emptyList();
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode#equals(de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode)
+ */
+ public boolean equals(ITaskTreeNode taskTreeNode) {
+ return false;
+ }
+
+ /* (non-Javadoc)
+ * @see java.lang.Object#clone()
+ */
+ @Override
+ public NullNode clone() {
+ return (NullNode) this;
+ }
+
+ /* (non-Javadoc)
+ * @see de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode#accept(de.ugoe.cs.autoquest.tasktrees.treeifc.NodeVisitor)
+ */
+ public void accept(NodeVisitor visitor) {
+
+ }
+
+}
+
Index: /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/util/PatternsVisitorUtil.java
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/util/PatternsVisitorUtil.java (revision 1150)
+++ /trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/util/PatternsVisitorUtil.java (revision 1150)
@@ -0,0 +1,74 @@
+// Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package de.ugoe.cs.autoquest.usability.util;
+
+import java.util.List;
+
+import com.google.common.collect.Iterables;
+
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory;
+
+/**
+ *
+ * TODO comment
+ *
+ *
+ * @author Alexander Deicke
+ */
+public class PatternsVisitorUtil {
+
+ private PatternsVisitorUtil() {
+ // no instantiation
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param taskTreeNode
+ * @return
+ */
+ public static ITaskTree createTaskTreeFromNode(ITaskTreeNode taskTreeNode) {
+ return new TaskTreeNodeFactory().createTaskTree(taskTreeNode);
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param taskTreeNodes
+ * @return
+ */
+ public static ITaskTreeNode firstNodeOf(List taskTreeNodes) {
+ return Iterables.getFirst(taskTreeNodes, new NullNode());
+ }
+
+ /**
+ *
+ * TODO: comment
+ *
+ *
+ * @param taskTreeNodes
+ * @return
+ */
+ public static ITaskTreeNode lastNodeOf(List taskTreeNodes) {
+ return Iterables.getLast(taskTreeNodes, new NullNode());
+ }
+
+}
Index: /trunk/autoquest-core-usability-evaluation/src/main/resources/defects.props
===================================================================
--- /trunk/autoquest-core-usability-evaluation/src/main/resources/defects.props (revision 1149)
+++ /trunk/autoquest-core-usability-evaluation/src/main/resources/defects.props (revision 1150)
@@ -37,2 +37,6 @@
severity.low = 0.5
severity.info = 0.3
+
+[LongFormUsageDefect]
+
+description = Long form detected.