Index: /trunk/autoquest-core-coverage-test/.classpath =================================================================== --- /trunk/autoquest-core-coverage-test/.classpath (revision 889) +++ /trunk/autoquest-core-coverage-test/.classpath (revision 889) @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + Index: /trunk/autoquest-core-coverage-test/.project =================================================================== --- /trunk/autoquest-core-coverage-test/.project (revision 889) +++ /trunk/autoquest-core-coverage-test/.project (revision 889) @@ -0,0 +1,23 @@ + + + quest-core-coverage-test + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.m2e.core.maven2Builder + + + + + + org.eclipse.m2e.core.maven2Nature + org.eclipse.jdt.core.javanature + + Index: /trunk/autoquest-core-coverage-test/.settings/org.eclipse.jdt.core.prefs =================================================================== --- /trunk/autoquest-core-coverage-test/.settings/org.eclipse.jdt.core.prefs (revision 889) +++ /trunk/autoquest-core-coverage-test/.settings/org.eclipse.jdt.core.prefs (revision 889) @@ -0,0 +1,5 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6 +org.eclipse.jdt.core.compiler.compliance=1.6 +org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning +org.eclipse.jdt.core.compiler.source=1.6 Index: /trunk/autoquest-core-coverage-test/.settings/org.eclipse.m2e.core.prefs =================================================================== --- /trunk/autoquest-core-coverage-test/.settings/org.eclipse.m2e.core.prefs (revision 889) +++ /trunk/autoquest-core-coverage-test/.settings/org.eclipse.m2e.core.prefs (revision 889) @@ -0,0 +1,4 @@ +activeProfiles= +eclipse.preferences.version=1 +resolveWorkspaceProjects=true +version=1 Index: /trunk/autoquest-core-coverage-test/pom.xml =================================================================== --- /trunk/autoquest-core-coverage-test/pom.xml (revision 889) +++ /trunk/autoquest-core-coverage-test/pom.xml (revision 889) @@ -0,0 +1,24 @@ + + + de.ugoe.cs.quest + quest-test + 0.0.1-SNAPSHOT + + 4.0.0 + quest-core-coverage-test + + quest-core-coverage + + + + de.ugoe.cs.quest + quest-core-usageprofiles + ${tested-quest-version} + test + + + Index: /trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/CoverageCalculatorObservedTest.java =================================================================== --- /trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/CoverageCalculatorObservedTest.java (revision 889) +++ /trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/CoverageCalculatorObservedTest.java (revision 889) @@ -0,0 +1,314 @@ +package de.ugoe.cs.quest.coverage; + +import java.util.ArrayList; +import java.util.Collection; +import de.ugoe.cs.quest.coverage.CoverageCalculatorObserved; +import de.ugoe.cs.quest.eventcore.Event; +import de.ugoe.cs.quest.eventcore.StringEventType; +import de.ugoe.cs.quest.usageprofiles.MockTrieBasedModel; + +import java.util.LinkedHashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Random; +import java.util.Set; + +import org.junit.*; + +import static org.junit.Assert.*; + +/** + * The class CoverageCalculatorObservedTest contains tests for the + * class {@link CoverageCalculatorObserved}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class CoverageCalculatorObservedTest { + + Collection> sequencesObserved; + + Set> sequencesCovered; + Set> sequencesCovered2; + Set> sequencesNewPossible; + + MockTrieBasedModel mockProcess; + + @Test + public void testCoverageCalculatorObserved_1() throws Exception { + int length = 2; + + CoverageCalculatorObserved result = new CoverageCalculatorObserved( + sequencesObserved, sequencesCovered, length); + assertNotNull(result); + } + + @Test(expected = java.lang.IllegalArgumentException.class) + public void testCoverageCalculatorObserved_2() throws Exception { + int length = 2; + + new CoverageCalculatorObserved(null,sequencesCovered, length); + } + + @Test(expected = java.lang.IllegalArgumentException.class) + public void testCoverageCalculatorObserved_3() throws Exception { + int length = 2; + + new CoverageCalculatorObserved(sequencesObserved, null, length); + } + + @Test(expected = java.lang.IllegalArgumentException.class) + public void testCoverageCalculatorObserved_4() throws Exception { + int length = 0; + + new CoverageCalculatorObserved(sequencesObserved, sequencesCovered, length); + } + + @Test(expected = java.lang.IllegalArgumentException.class) + public void testCoverageCalculatorObserved_5() throws Exception { + int length = -1; + + new CoverageCalculatorObserved(sequencesObserved, sequencesCovered, length); + } + + @Test + public void testCoverageObserved_1() throws Exception { + int length = 2; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesCovered, length); + + double result = fixture.getCoverageObserved(); + + assertEquals(3.0/6.0, result, 0.0001); + } + + @Test + public void testCoverageObserved_2() throws Exception { + int length = 2; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesCovered2, length); + + double result = fixture.getCoverageObserved(); + + assertEquals(2.0/6.0, result, 0.0001); + } + + @Test + public void testCoverageObservedWeigth_1() throws Exception { + int length = 2; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesCovered, length); + + double result = fixture.getCoverageObservedWeigth(mockProcess); + + assertEquals(6.0, result, 0.0001); + } + + @Test + public void testCoverageObservedWeigth_2() throws Exception { + int length = 2; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesCovered2, length); + + double result = fixture.getCoverageObservedWeigth(mockProcess); + + assertEquals(4.0, result, 0.0001); + } + + @Test + public void testGetNewPercentage_1() throws Exception { + int length = 2; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesCovered, length); + + double result = fixture.getNewPercentage(); + + assertEquals(1.0/4.0, result, 0.0001); + } + + @Test + public void testGetNewPercentage_2() throws Exception { + int length = 2; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesCovered2, length); + + double result = fixture.getNewPercentage(); + + assertEquals(0.0, result, 0.0001); + } + + @Test + public void testCoveragePossibleNew_1() throws Exception { + int length = 3; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesNewPossible, length); + + double result = fixture.getCoveragePossibleNew(mockProcess); + + assertEquals(1.0/11.0, result, 0.0001); + } + + @Test + public void testCoveragePossibleNew_2() throws Exception { + int length = 2; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesCovered, length); + + double result = fixture.getCoveragePossibleNew(mockProcess); + + assertEquals(0.0, result, 0.0001); + } + + @Test(expected = java.lang.IllegalArgumentException.class ) + public void testCoveragePossibleNew_3() throws Exception { + int length = 3; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesCovered, length); + + fixture.getCoveragePossibleNew(null); + } + + @Test + public void testCoveragePossibleNewWeight_1() throws Exception { + int length = 3; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesNewPossible, length); + + double result = fixture.getCoveragePossibleNewWeight(mockProcess); + + assertEquals(2.0, result, 0.0001); + } + + @Test + public void testCoveragePossibleNewWeight_2() throws Exception { + int length = 2; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesCovered, length); + + double result = fixture.getCoveragePossibleNewWeight(mockProcess); + + assertEquals(0.0, result, 0.0001); + } + + @Test(expected = java.lang.IllegalArgumentException.class ) + public void testCoveragePossibleNewWeight_3() throws Exception { + int length = 3; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesCovered, length); + + fixture.getCoveragePossibleNewWeight(null); + } + + + @Test + public void testGetNumObserved_1() throws Exception { + int length = 2; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesCovered, length); + + int result = fixture.getNumObserved(); + + assertEquals(6, result); + } + + @Test + public void testGetNumCovered_1() throws Exception { + int length = 2; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesCovered, length); + + int result = fixture.getNumCovered(); + + assertEquals(4, result); + } + + @Test + public void testGetNumCovered_2() throws Exception { + int length = 2; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesCovered2, length); + + int result = fixture.getNumCovered(); + + assertEquals(2, result); + } + + @Test + public void testGetNumNew_1() throws Exception { + int length = 2; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesCovered, length); + + int result = fixture.getNumNew(); + + assertEquals(1, result); + } + + @Test + public void testGetNumNew_2() throws Exception { + int length = 2; + CoverageCalculatorObserved fixture = new CoverageCalculatorObserved( + sequencesObserved, sequencesCovered2, length); + + int result = fixture.getNumNew(); + + assertEquals(0, result); + } + + @Before + public void setUp() throws Exception { + sequencesObserved = new LinkedList>(); + List sequence1 = new ArrayList(); + sequence1.add(new Event(new StringEventType("a"))); + sequence1.add(new Event(new StringEventType("b"))); + sequence1.add(new Event(new StringEventType("r"))); + sequence1.add(new Event(new StringEventType("a"))); + List sequence2 = new ArrayList(); + sequence2.add(new Event(new StringEventType("c"))); + sequence2.add(new Event(new StringEventType("a"))); + sequence2.add(new Event(new StringEventType("d"))); + sequence2.add(new Event(new StringEventType("a"))); + sequence2.add(new Event(new StringEventType("b"))); + sequence2.add(new Event(new StringEventType("r"))); + sequence2.add(new Event(new StringEventType("a"))); + sequencesObserved.add(sequence1); + sequencesObserved.add(sequence2); + + sequencesCovered = new LinkedHashSet>(); + List tmpList = new ArrayList(); + tmpList.add(new Event(new StringEventType("a"))); + tmpList.add(new Event(new StringEventType("b"))); + tmpList.add(new Event(new StringEventType("r"))); + sequencesCovered.add(tmpList); + tmpList = new ArrayList(); + tmpList.add(new Event(new StringEventType("b"))); + tmpList.add(new Event(new StringEventType("r"))); + tmpList.add(new Event(new StringEventType("a"))); + tmpList.add(new Event(new StringEventType("e"))); + sequencesCovered.add(tmpList); + + sequencesCovered2 = new LinkedHashSet>(); + tmpList = new ArrayList(); + tmpList.add(new Event(new StringEventType("a"))); + tmpList.add(new Event(new StringEventType("b"))); + tmpList.add(new Event(new StringEventType("r"))); + sequencesCovered2.add(tmpList); + + sequencesNewPossible = new LinkedHashSet>(); + tmpList = new ArrayList(); + tmpList.add(new Event(new StringEventType("r"))); + tmpList.add(new Event(new StringEventType("a"))); + tmpList.add(new Event(new StringEventType("b"))); + sequencesNewPossible.add(tmpList); + + int markovOrder = 2; + mockProcess = new MockTrieBasedModel(markovOrder, new Random()); + mockProcess.train(sequencesObserved); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore() + .run(CoverageCalculatorObservedTest.class); + } + +} Index: /trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/CoverageCalculatorProcessTest.java =================================================================== --- /trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/CoverageCalculatorProcessTest.java (revision 889) +++ /trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/CoverageCalculatorProcessTest.java (revision 889) @@ -0,0 +1,237 @@ +package de.ugoe.cs.quest.coverage; + +import java.util.ArrayList; +import java.util.Collection; + +import java.util.LinkedHashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Random; +import java.util.Set; +import de.ugoe.cs.quest.coverage.CoverageCalculatorProcess; +import de.ugoe.cs.quest.eventcore.Event; +import de.ugoe.cs.quest.eventcore.StringEventType; +import de.ugoe.cs.quest.usageprofiles.MockTrieBasedModel; + +import org.junit.*; + +import static org.junit.Assert.*; + +/** + * The class CoverageCalculatorProcessTest contains tests for the + * class {@link CoverageCalculatorProcess}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class CoverageCalculatorProcessTest { + + Set> sequencesCovered; + Set> sequencesCovered2; + MockTrieBasedModel mockProcess; + + @Test + public void testCoverageCalculatorProcess_1() throws Exception { + int length = 2; + + CoverageCalculatorProcess result = new CoverageCalculatorProcess( + mockProcess, sequencesCovered, length); + assertNotNull(result); + } + + @Test(expected = java.lang.IllegalArgumentException.class) + public void testCoverageCalculatorProcess_2() throws Exception { + int length = 2; + + new CoverageCalculatorProcess(null,sequencesCovered, length); + } + + @Test(expected = java.lang.IllegalArgumentException.class) + public void testCoverageCalculatorProcess_3() throws Exception { + int length = 2; + + new CoverageCalculatorProcess(mockProcess, null, length); + } + + @Test(expected = java.lang.IllegalArgumentException.class) + public void testCoverageCalculatorProcess_4() throws Exception { + int length = 0; + + new CoverageCalculatorProcess(mockProcess, sequencesCovered, length); + } + + @Test(expected = java.lang.IllegalArgumentException.class) + public void testCoverageCalculatorProcess_5() throws Exception { + int length = -1; + + new CoverageCalculatorProcess(mockProcess, sequencesCovered, length); + } + + @Test + public void testGetCoverageAllNoWeight_1() throws Exception { + int length = 2; + CoverageCalculatorProcess fixture = new CoverageCalculatorProcess( + mockProcess, sequencesCovered, length); + + double result = fixture.getCoverageAllNoWeight(); + + assertEquals(3.0 / 49.0, result, 0.0001); + } + + @Test + public void testGetCoverageAllNoWeight_2() throws Exception { + int length = 2; + CoverageCalculatorProcess fixture = new CoverageCalculatorProcess( + mockProcess, sequencesCovered2, length); + + double result = fixture.getCoverageAllNoWeight(); + + assertEquals(2.0 / 49.0, result, 0.0001); + } + + @Test + public void testGetCoveragePossibleNoWeight_1() throws Exception { + int length = 2; + CoverageCalculatorProcess fixture = new CoverageCalculatorProcess( + mockProcess, sequencesCovered, length); + + double result = fixture.getCoveragePossibleNoWeight(); + + assertEquals(3.0 / 9.0, result, 0.0001); + } + + @Test + public void testGetCoveragePossibleNoWeight_2() throws Exception { + int length = 2; + CoverageCalculatorProcess fixture = new CoverageCalculatorProcess( + mockProcess, sequencesCovered2, length); + + double result = fixture.getCoveragePossibleNoWeight(); + + assertEquals(2.0 / 9.0, result, 0.0001); + } + + @Test + public void testGetCoveragePossibleWeight_1() throws Exception { + int length = 2; + CoverageCalculatorProcess fixture = new CoverageCalculatorProcess( + mockProcess, sequencesCovered, length); + + double result = fixture.getCoveragePossibleWeight(); + + assertEquals(6.0, result, 0.0001); + } + + @Test + public void testGetCoveragePossibleWeight_2() throws Exception { + int length = 2; + CoverageCalculatorProcess fixture = new CoverageCalculatorProcess( + mockProcess, sequencesCovered2, length); + + double result = fixture.getCoveragePossibleWeight(); + + assertEquals(4.0, result, 0.0001); + } + + @Test + public void testGetNumCovered_1() throws Exception { + int length = 2; + CoverageCalculatorProcess fixture = new CoverageCalculatorProcess( + mockProcess, sequencesCovered, length); + + int result = fixture.getNumCovered(); + + assertEquals(3, result); + } + + @Test + public void testGetNumCovered_2() throws Exception { + int length = 2; + CoverageCalculatorProcess fixture = new CoverageCalculatorProcess( + mockProcess, sequencesCovered2, length); + + int result = fixture.getNumCovered(); + + assertEquals(2, result); + } + + @Test + public void testGetNumPossible_1() throws Exception { + int length = 2; + CoverageCalculatorProcess fixture = new CoverageCalculatorProcess( + mockProcess, sequencesCovered, length); + + int result = fixture.getNumPossible(); + + assertEquals(9, result); + } + + @Test + public void testSetSequences_1() throws Exception { + int length = 2; + CoverageCalculatorProcess fixture = new CoverageCalculatorProcess( + mockProcess, sequencesCovered, length); + + fixture.setSequences(sequencesCovered2); + + // testing indirectly if sequences were changed + assertEquals(2, fixture.getNumCovered()); + } + + @Test(expected = java.lang.IllegalArgumentException.class) + public void testSetSequences_2() throws Exception { + int length = 2; + CoverageCalculatorProcess fixture = new CoverageCalculatorProcess( + mockProcess, sequencesCovered, length); + + fixture.setSequences(null); + } + + @Before + public void setUp() throws Exception { + Collection> sequences = new LinkedList>(); + List sequence1 = new ArrayList(); + sequence1.add(new Event(new StringEventType("a"))); + sequence1.add(new Event(new StringEventType("b"))); + sequence1.add(new Event(new StringEventType("r"))); + sequence1.add(new Event(new StringEventType("a"))); + List sequence2 = new ArrayList(); + sequence2.add(new Event(new StringEventType("c"))); + sequence2.add(new Event(new StringEventType("a"))); + sequence2.add(new Event(new StringEventType("d"))); + sequence2.add(new Event(new StringEventType("a"))); + sequence2.add(new Event(new StringEventType("b"))); + sequence2.add(new Event(new StringEventType("r"))); + sequence2.add(new Event(new StringEventType("a"))); + sequences.add(sequence1); + sequences.add(sequence2); + + sequencesCovered = new LinkedHashSet>(); + List tmpList = new ArrayList(); + tmpList.add(new Event(new StringEventType("a"))); + tmpList.add(new Event(new StringEventType("b"))); + tmpList.add(new Event(new StringEventType("r"))); + sequencesCovered.add(tmpList); + tmpList = new ArrayList(); + tmpList.add(new Event(new StringEventType("b"))); + tmpList.add(new Event(new StringEventType("r"))); + tmpList.add(new Event(new StringEventType("a"))); + sequencesCovered.add(tmpList); + + sequencesCovered2 = new LinkedHashSet>(); + tmpList = new ArrayList(); + tmpList.add(new Event(new StringEventType("a"))); + tmpList.add(new Event(new StringEventType("b"))); + tmpList.add(new Event(new StringEventType("r"))); + sequencesCovered2.add(tmpList); + + int markovOrder = 2; + mockProcess = new MockTrieBasedModel(markovOrder, new Random()); + mockProcess.train(sequences); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore() + .run(CoverageCalculatorProcessTest.class); + } +} Index: /trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/SequenceToolsTest.java =================================================================== --- /trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/SequenceToolsTest.java (revision 889) +++ /trunk/autoquest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/SequenceToolsTest.java (revision 889) @@ -0,0 +1,202 @@ +package de.ugoe.cs.quest.coverage; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.LinkedHashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Random; +import java.util.Set; +import de.ugoe.cs.quest.coverage.SequenceTools; +import de.ugoe.cs.quest.eventcore.Event; +import de.ugoe.cs.quest.eventcore.StringEventType; +import de.ugoe.cs.quest.usageprofiles.FirstOrderMarkovModel; +import de.ugoe.cs.quest.usageprofiles.IStochasticProcess; +import de.ugoe.cs.quest.usageprofiles.MockTrieBasedModel; + +import org.junit.*; + +import static org.junit.Assert.*; + +/** + * The class SequenceToolsTest contains tests for the class {@link SequenceTools}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class SequenceToolsTest { + + Collection> sequences; + Set> subSequences; + MockTrieBasedModel mockProcess; + + @Test + public void testContainedSubSequences_1() + throws Exception { + int length = 2; + + Set> result = SequenceTools.containedSubSequences(sequences, length); + + assertNotNull(result); + assertTrue(result.containsAll(subSequences)); + assertEquals(subSequences.size(), result.size()); + } + + @Test + public void testContainedSubSequences_2() + throws Exception { + int length = 2; + + Set> result = SequenceTools.containedSubSequences(null, length); + assertNotNull(result); + assertTrue(result.isEmpty()); + } + + @Test(expected=java.lang.IllegalArgumentException.class) + public void testContainedSubSequences_3() + throws Exception { + int length = 0; + + SequenceTools.containedSubSequences(sequences, length); + } + + @Test(expected=java.lang.IllegalArgumentException.class) + public void testContainedSubSequences_4() + throws Exception { + int length = -1; + + SequenceTools.containedSubSequences(sequences, length); + } + + @Test + public void testGenerateWeights_1() + throws Exception { + Map, Double> result = SequenceTools.generateWeights(mockProcess, subSequences); + + assertNotNull(result); + Set, Double>> entrySet = result.entrySet(); + assertEquals(subSequences.size(),entrySet.size()); + for( Entry, Double> entry : entrySet ) { + assertEquals(Double.valueOf(2.0d), entry.getValue()); + assertTrue(subSequences.contains(entry.getKey())); + } + } + + @Test + public void testGenerateWeights_2() + throws Exception { + Map, Double> result = SequenceTools.generateWeights(null, subSequences); + + Set, Double>> entrySet = result.entrySet(); + assertEquals(subSequences.size(),entrySet.size()); + for( Entry, Double> entry : entrySet ) { + assertEquals(Double.valueOf(0.0d), entry.getValue()); + assertTrue(subSequences.contains(entry.getKey())); + } + } + + @Test + public void testGenerateWeights_3() + throws Exception { + Map, Double> result = SequenceTools.generateWeights(mockProcess, null); + + assertNotNull(result); + assertTrue(result.isEmpty()); + } + + @Test + public void testNumSequences_1() + throws Exception { + int length = 2; + int expected = 49; + + long result = SequenceTools.numSequences(mockProcess, length); + + assertEquals(expected, result); + } + + @Test + public void testNumSequences_2() + throws Exception { + int length = 2; + int expected = 49; + + long result = SequenceTools.numSequences(mockProcess, length); + + assertEquals(expected, result); + } + + @Test(expected = java.lang.IllegalArgumentException.class ) + public void testNumSequences_3() + throws Exception { + int length = 0; + + SequenceTools.numSequences(mockProcess, length); + } + + @Test(expected = java.lang.IllegalArgumentException.class ) + public void testNumSequences_4() + throws Exception { + IStochasticProcess process = new FirstOrderMarkovModel(new Random()); + int length = -1; + + SequenceTools.numSequences(process, length); + } + + @Before + public void setUp() + throws Exception { + sequences = new LinkedList>(); + List sequence1 = new ArrayList(); + sequence1.add(new Event(new StringEventType("a"))); + sequence1.add(new Event(new StringEventType("b"))); + sequence1.add(new Event(new StringEventType("r"))); + sequence1.add(new Event(new StringEventType("a"))); + List sequence2 = new ArrayList(); + sequence2.add(new Event(new StringEventType("c"))); + sequence2.add(new Event(new StringEventType("a"))); + sequence2.add(new Event(new StringEventType("d"))); + sequence2.add(new Event(new StringEventType("a"))); + sequence2.add(new Event(new StringEventType("b"))); + sequence2.add(new Event(new StringEventType("r"))); + sequence2.add(new Event(new StringEventType("a"))); + sequences.add(sequence1); + sequences.add(sequence2); + + subSequences = new LinkedHashSet>(); + List tmpList = new ArrayList(); + tmpList.add(new Event(new StringEventType("a"))); + tmpList.add(new Event(new StringEventType("b"))); + subSequences.add(tmpList); + tmpList = new ArrayList(); + tmpList.add(new Event(new StringEventType("b"))); + tmpList.add(new Event(new StringEventType("r"))); + subSequences.add(tmpList); + tmpList = new ArrayList(); + tmpList.add(new Event(new StringEventType("r"))); + tmpList.add(new Event(new StringEventType("a"))); + subSequences.add(tmpList); + tmpList = new ArrayList(); + tmpList.add(new Event(new StringEventType("c"))); + tmpList.add(new Event(new StringEventType("a"))); + subSequences.add(tmpList); + tmpList = new ArrayList(); + tmpList.add(new Event(new StringEventType("a"))); + tmpList.add(new Event(new StringEventType("d"))); + subSequences.add(tmpList); + tmpList = new ArrayList(); + tmpList.add(new Event(new StringEventType("d"))); + tmpList.add(new Event(new StringEventType("a"))); + subSequences.add(tmpList); + + int markovOrder = 2; + mockProcess = new MockTrieBasedModel(markovOrder, new Random()); + mockProcess.train(sequences); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(SequenceToolsTest.class); + } +}