Index: trunk/quest-core-coverage-test/.classpath =================================================================== --- trunk/quest-core-coverage-test/.classpath (revision 518) +++ trunk/quest-core-coverage-test/.classpath (revision 518) @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + Index: trunk/quest-core-coverage-test/.project =================================================================== --- trunk/quest-core-coverage-test/.project (revision 518) +++ trunk/quest-core-coverage-test/.project (revision 518) @@ -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/quest-core-coverage-test/.settings/org.eclipse.jdt.core.prefs =================================================================== --- trunk/quest-core-coverage-test/.settings/org.eclipse.jdt.core.prefs (revision 518) +++ trunk/quest-core-coverage-test/.settings/org.eclipse.jdt.core.prefs (revision 518) @@ -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/quest-core-coverage-test/.settings/org.eclipse.m2e.core.prefs =================================================================== --- trunk/quest-core-coverage-test/.settings/org.eclipse.m2e.core.prefs (revision 518) +++ trunk/quest-core-coverage-test/.settings/org.eclipse.m2e.core.prefs (revision 518) @@ -0,0 +1,4 @@ +activeProfiles= +eclipse.preferences.version=1 +resolveWorkspaceProjects=true +version=1 Index: trunk/quest-core-coverage-test/pom.xml =================================================================== --- trunk/quest-core-coverage-test/pom.xml (revision 518) +++ trunk/quest-core-coverage-test/pom.xml (revision 518) @@ -0,0 +1,150 @@ + + 4.0.0 + de.ugoe.cs.quest + quest-core-coverage-test + 0.0.1-SNAPSHOT + quest-core-coverage-test + + https://quest.informatik.uni-goettingen.de/svn/quest/trunk/quest-core-events-test + + + + de.ugoe.cs.quest + quest-core-events + 0.0.1-SNAPSHOT + test + + + de.ugoe.cs.quest + quest-core-usageprofiles-test + 0.0.1-SNAPSHOT + test + + + de.ugoe.cs.quest + quest-core-coverage + 0.0.1-SNAPSHOT + test + + + junit + junit + 4.8.1 + test + + + + + + + + org.eclipse.m2e + lifecycle-mapping + 1.0.0 + + + + + + org.apache.maven.plugins + maven-dependency-plugin + [1.0.0,) + + unpack + + + + + + + + + org.codehaus.mojo + emma-maven-plugin + [1.0-alpha-3,) + + emma + + + + + + + + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 2.3.2 + + 1.6 + 1.6 + + + + org.apache.maven.plugins + maven-dependency-plugin + 2.4 + + + unpack + process-classes + + unpack + + + + + de.ugoe.cs.quest + quest-core-coverage + 0.0.1-SNAPSHOT + ${project.build.directory}/classes + + + + + + + + org.codehaus.mojo + emma-maven-plugin + 1.0-alpha-3 + true + + + process-classes + + emma + + + + + + org.apache.maven.plugins + maven-jar-plugin + 2.3.2 + + + + test-jar + + + + + + + Index: trunk/quest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/CoverageCalculatorObservedTest.java =================================================================== --- trunk/quest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/CoverageCalculatorObservedTest.java (revision 518) +++ trunk/quest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/CoverageCalculatorObservedTest.java (revision 518) @@ -0,0 +1,313 @@ +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.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.security.InvalidParameterException.class) + public void testCoverageCalculatorObserved_2() throws Exception { + int length = 2; + + new CoverageCalculatorObserved(null,sequencesCovered, length); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testCoverageCalculatorObserved_3() throws Exception { + int length = 2; + + new CoverageCalculatorObserved(sequencesObserved, null, length); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testCoverageCalculatorObserved_4() throws Exception { + int length = 0; + + new CoverageCalculatorObserved(sequencesObserved, sequencesCovered, length); + } + + @Test(expected = java.security.InvalidParameterException.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.security.InvalidParameterException.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.security.InvalidParameterException.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("a")); + sequence1.add(new Event("b")); + sequence1.add(new Event("r")); + sequence1.add(new Event("a")); + List> sequence2 = new ArrayList>(); + sequence2.add(new Event("c")); + sequence2.add(new Event("a")); + sequence2.add(new Event("d")); + sequence2.add(new Event("a")); + sequence2.add(new Event("b")); + sequence2.add(new Event("r")); + sequence2.add(new Event("a")); + sequencesObserved.add(sequence1); + sequencesObserved.add(sequence2); + + sequencesCovered = new LinkedHashSet>>(); + List> tmpList = new ArrayList>(); + tmpList.add(new Event("a")); + tmpList.add(new Event("b")); + tmpList.add(new Event("r")); + sequencesCovered.add(tmpList); + tmpList = new ArrayList>(); + tmpList.add(new Event("b")); + tmpList.add(new Event("r")); + tmpList.add(new Event("a")); + tmpList.add(new Event("e")); + sequencesCovered.add(tmpList); + + sequencesCovered2 = new LinkedHashSet>>(); + tmpList = new ArrayList>(); + tmpList.add(new Event("a")); + tmpList.add(new Event("b")); + tmpList.add(new Event("r")); + sequencesCovered2.add(tmpList); + + sequencesNewPossible = new LinkedHashSet>>(); + tmpList = new ArrayList>(); + tmpList.add(new Event("r")); + tmpList.add(new Event("a")); + tmpList.add(new Event("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/quest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/CoverageCalculatorProcessTest.java =================================================================== --- trunk/quest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/CoverageCalculatorProcessTest.java (revision 518) +++ trunk/quest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/CoverageCalculatorProcessTest.java (revision 518) @@ -0,0 +1,236 @@ +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.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.security.InvalidParameterException.class) + public void testCoverageCalculatorProcess_2() throws Exception { + int length = 2; + + new CoverageCalculatorProcess(null,sequencesCovered, length); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testCoverageCalculatorProcess_3() throws Exception { + int length = 2; + + new CoverageCalculatorProcess(mockProcess, null, length); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testCoverageCalculatorProcess_4() throws Exception { + int length = 0; + + new CoverageCalculatorProcess(mockProcess, sequencesCovered, length); + } + + @Test(expected = java.security.InvalidParameterException.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.security.InvalidParameterException.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("a")); + sequence1.add(new Event("b")); + sequence1.add(new Event("r")); + sequence1.add(new Event("a")); + List> sequence2 = new ArrayList>(); + sequence2.add(new Event("c")); + sequence2.add(new Event("a")); + sequence2.add(new Event("d")); + sequence2.add(new Event("a")); + sequence2.add(new Event("b")); + sequence2.add(new Event("r")); + sequence2.add(new Event("a")); + sequences.add(sequence1); + sequences.add(sequence2); + + sequencesCovered = new LinkedHashSet>>(); + List> tmpList = new ArrayList>(); + tmpList.add(new Event("a")); + tmpList.add(new Event("b")); + tmpList.add(new Event("r")); + sequencesCovered.add(tmpList); + tmpList = new ArrayList>(); + tmpList.add(new Event("b")); + tmpList.add(new Event("r")); + tmpList.add(new Event("a")); + sequencesCovered.add(tmpList); + + sequencesCovered2 = new LinkedHashSet>>(); + tmpList = new ArrayList>(); + tmpList.add(new Event("a")); + tmpList.add(new Event("b")); + tmpList.add(new Event("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/quest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/SequenceToolsTest.java =================================================================== --- trunk/quest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/SequenceToolsTest.java (revision 518) +++ trunk/quest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/SequenceToolsTest.java (revision 518) @@ -0,0 +1,201 @@ +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.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.security.InvalidParameterException.class) + public void testContainedSubSequences_3() + throws Exception { + int length = 0; + + SequenceTools.containedSubSequences(sequences, length); + } + + @Test(expected=java.security.InvalidParameterException.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.security.InvalidParameterException.class ) + public void testNumSequences_3() + throws Exception { + int length = 0; + + SequenceTools.numSequences(mockProcess, length); + } + + @Test(expected = java.security.InvalidParameterException.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("a")); + sequence1.add(new Event("b")); + sequence1.add(new Event("r")); + sequence1.add(new Event("a")); + List> sequence2 = new ArrayList>(); + sequence2.add(new Event("c")); + sequence2.add(new Event("a")); + sequence2.add(new Event("d")); + sequence2.add(new Event("a")); + sequence2.add(new Event("b")); + sequence2.add(new Event("r")); + sequence2.add(new Event("a")); + sequences.add(sequence1); + sequences.add(sequence2); + + subSequences = new LinkedHashSet>>(); + List> tmpList = new ArrayList>(); + tmpList.add(new Event("a")); + tmpList.add(new Event("b")); + subSequences.add(tmpList); + tmpList = new ArrayList>(); + tmpList.add(new Event("b")); + tmpList.add(new Event("r")); + subSequences.add(tmpList); + tmpList = new ArrayList>(); + tmpList.add(new Event("r")); + tmpList.add(new Event("a")); + subSequences.add(tmpList); + tmpList = new ArrayList>(); + tmpList.add(new Event("c")); + tmpList.add(new Event("a")); + subSequences.add(tmpList); + tmpList = new ArrayList>(); + tmpList.add(new Event("a")); + tmpList.add(new Event("d")); + subSequences.add(tmpList); + tmpList = new ArrayList>(); + tmpList.add(new Event("d")); + tmpList.add(new Event("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); + } +} Index: trunk/quest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/TestAll.java =================================================================== --- trunk/quest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/TestAll.java (revision 518) +++ trunk/quest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/TestAll.java (revision 518) @@ -0,0 +1,26 @@ +package de.ugoe.cs.quest.coverage; + +import org.junit.runner.JUnitCore; +import org.junit.runner.RunWith; +import org.junit.runners.Suite; + +/** + * The class TestAll builds a suite that can be used to run all + * of the tests within its package as well as within any subpackages of its + * package. + * + * @author Steffen Herbold + * @version 1.0 + */ +@RunWith(Suite.class) +@Suite.SuiteClasses({ + CoverageCalculatorObservedTest.class, + CoverageCalculatorProcessTest.class, + SequenceToolsTest.class +}) +public class TestAll { + + public static void main(String[] args) { + JUnitCore.runClasses(new Class[] { TestAll.class }); + } +}