Index: trunk/quest-core-usageprofiles-test/.classpath =================================================================== --- trunk/quest-core-usageprofiles-test/.classpath (revision 518) +++ trunk/quest-core-usageprofiles-test/.classpath (revision 518) @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + + + + + + Index: trunk/quest-core-usageprofiles-test/.project =================================================================== --- trunk/quest-core-usageprofiles-test/.project (revision 518) +++ trunk/quest-core-usageprofiles-test/.project (revision 518) @@ -0,0 +1,23 @@ + + + quest-core-usageprofiles-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-usageprofiles-test/.settings/org.eclipse.jdt.core.prefs =================================================================== --- trunk/quest-core-usageprofiles-test/.settings/org.eclipse.jdt.core.prefs (revision 518) +++ trunk/quest-core-usageprofiles-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-usageprofiles-test/.settings/org.eclipse.m2e.core.prefs =================================================================== --- trunk/quest-core-usageprofiles-test/.settings/org.eclipse.m2e.core.prefs (revision 518) +++ trunk/quest-core-usageprofiles-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-usageprofiles-test/pom.xml =================================================================== --- trunk/quest-core-usageprofiles-test/pom.xml (revision 518) +++ trunk/quest-core-usageprofiles-test/pom.xml (revision 518) @@ -0,0 +1,139 @@ + + 4.0.0 + de.ugoe.cs.quest + quest-core-usageprofiles-test + 0.0.1-SNAPSHOT + quest-core-usageprofiles-test + + https://quest.informatik.uni-goettingen.de/svn/quest/trunk/quest-core-usageprofiles-test + + + + de.ugoe.cs.quest + quest-core-events + 0.0.1-SNAPSHOT + test + + + de.ugoe.cs.quest + quest-core-usageprofiles + 0.0.1-SNAPSHOT + test + + + junit + junit + 4.8.1 + test + + + junit-addons + junit-addons + 1.4 + + + + + + + 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-usageprofiles + 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-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/DeterministicFiniteAutomatonTest.java =================================================================== --- trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/DeterministicFiniteAutomatonTest.java (revision 518) +++ trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/DeterministicFiniteAutomatonTest.java (revision 518) @@ -0,0 +1,157 @@ +package de.ugoe.cs.quest.usageprofiles; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import de.ugoe.cs.quest.eventcore.Event; +import de.ugoe.cs.quest.usageprofiles.DeterministicFiniteAutomaton; + +import java.util.Random; +import org.junit.*; + +import static org.junit.Assert.*; + +/** + * The class DeterministicFiniteAutomatonTest contains tests for + * the class {@link DeterministicFiniteAutomaton}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class DeterministicFiniteAutomatonTest { + + Collection>> sequences; + + @Test + public void testDeterministicFiniteAutomaton_1() throws Exception { + Random r = new Random(); + + DeterministicFiniteAutomaton result = new DeterministicFiniteAutomaton( + r); + + assertNotNull(result); + assertEquals(2, result.trieOrder); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testDeterministicFiniteAutomaton_2() throws Exception { + new DeterministicFiniteAutomaton(null); + } + + @Test + public void testGetProbability_1() throws Exception { + DeterministicFiniteAutomaton fixture = new DeterministicFiniteAutomaton( + new Random()); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(new Event("a")); + context.add(new Event("b")); + + Event symbol = new Event("r"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(1.0d, result, 0.0001); + } + + @Test + public void testGetProbability_2() throws Exception { + DeterministicFiniteAutomaton fixture = new DeterministicFiniteAutomaton( + new Random()); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(new Event("a")); + + Event symbol = new Event("b"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(1.0d / 4.0, result, 0.0001); + } + + @Test + public void testGetProbability_3() throws Exception { + DeterministicFiniteAutomaton fixture = new DeterministicFiniteAutomaton( + new Random()); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(new Event("a")); + + Event symbol = new Event("c"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(1.0d / 4.0, result, 0.0001); + } + + @Test + public void testGetProbability_4() throws Exception { + DeterministicFiniteAutomaton fixture = new DeterministicFiniteAutomaton( + new Random()); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(new Event("a")); + + Event symbol = new Event("e"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(0.0d, result, 0.0001); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testGetProbability_5() throws Exception { + DeterministicFiniteAutomaton fixture = new DeterministicFiniteAutomaton( + new Random()); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(new Event("a")); + + Event symbol = null; + + fixture.getProbability(context, symbol); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testGetProbability_6() throws Exception { + DeterministicFiniteAutomaton fixture = new DeterministicFiniteAutomaton( + new Random()); + fixture.train(sequences); + + List> context = null; + + Event symbol = new Event("a"); + + fixture.getProbability(context, symbol); + } + + @Before + public void setUp() throws Exception { + List> sequence = new ArrayList>(); + sequence.add(new Event("a")); + sequence.add(new Event("b")); + sequence.add(new Event("r")); + sequence.add(new Event("a")); + sequence.add(new Event("c")); + sequence.add(new Event("a")); + sequence.add(new Event("d")); + sequence.add(new Event("a")); + sequence.add(new Event("b")); + sequence.add(new Event("r")); + sequence.add(new Event("a")); + + sequences = new ArrayList>>(); + sequences.add(sequence); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore() + .run(DeterministicFiniteAutomatonTest.class); + } +} Index: trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/FirstOrderMarkovModelTest.java =================================================================== --- trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/FirstOrderMarkovModelTest.java (revision 518) +++ trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/FirstOrderMarkovModelTest.java (revision 518) @@ -0,0 +1,94 @@ +package de.ugoe.cs.quest.usageprofiles; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Random; +import org.junit.*; + +import de.ugoe.cs.quest.eventcore.Event; +import de.ugoe.cs.quest.usageprofiles.FirstOrderMarkovModel; +import de.ugoe.cs.quest.usageprofiles.FirstOrderMarkovModel.MarkovEdge; +import static org.junit.Assert.*; + +/** + * The class FirstOrderMarkovModelTest contains tests for the class + * {@link FirstOrderMarkovModel}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class FirstOrderMarkovModelTest { + + Collection>> sequences; + + @Test + public void testFirstOrderMarkovModel_1() throws Exception { + Random r = new Random(); + + FirstOrderMarkovModel result = new FirstOrderMarkovModel(r); + + assertNotNull(result); + assertEquals(r, result.r); + assertEquals(2, result.trieOrder); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testFirstOrderMarkovModel_2() throws Exception { + new FirstOrderMarkovModel(null); + } + + @Test + public void testCalcEntropy() throws Exception { + Random r = new Random(); + FirstOrderMarkovModel fixture = new FirstOrderMarkovModel(r); + fixture.train(sequences); + + double result = fixture.calcEntropy(); + + assertEquals(0.7392d, result, 0.0001); + } + + @Test + public void testMarkovEdgeMarkovEdge_1() throws Exception { + double weight = 0.2d; + + MarkovEdge result = new MarkovEdge(weight); + + assertNotNull(result); + assertEquals(weight, result.weight, 0.0001); + } + + @Test + public void testMarkovEdgeToString_1() throws Exception { + double weight = 0.2d; + MarkovEdge fixture = new MarkovEdge(weight); + + String result = fixture.toString(); + + assertEquals(Double.toString(0.2d), result); + } + + @Before + public void setUp() throws Exception { + List> sequence = new ArrayList>(); + sequence.add(new Event("a")); + sequence.add(new Event("b")); + sequence.add(new Event("r")); + sequence.add(new Event("a")); + sequence.add(new Event("c")); + sequence.add(new Event("a")); + sequence.add(new Event("d")); + sequence.add(new Event("a")); + sequence.add(new Event("b")); + sequence.add(new Event("r")); + sequence.add(new Event("a")); + + sequences = new ArrayList>>(); + sequences.add(sequence); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(FirstOrderMarkovModelTest.class); + } +} Index: trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/HighOrderMarkovModelTest.java =================================================================== --- trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/HighOrderMarkovModelTest.java (revision 518) +++ trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/HighOrderMarkovModelTest.java (revision 518) @@ -0,0 +1,241 @@ +package de.ugoe.cs.quest.usageprofiles; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import de.ugoe.cs.quest.eventcore.Event; +import de.ugoe.cs.quest.usageprofiles.HighOrderMarkovModel; + +import java.util.Random; +import org.junit.*; + +import static org.junit.Assert.*; + +/** + * The class HighOrderMarkovModelTest contains tests for the class + * {@link HighOrderMarkovModel}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class HighOrderMarkovModelTest { + + Collection>> sequences; + + @Test + public void testHighOrderMarkovModel_1() throws Exception { + int maxOrder = 1; + Random r = new Random(); + + HighOrderMarkovModel result = new HighOrderMarkovModel(maxOrder, r); + + assertNotNull(result); + assertEquals(r, result.r); + assertEquals(maxOrder + 1, result.trieOrder); + } + + @Test + public void testHighOrderMarkovModel_2() throws Exception { + int maxOrder = 0; + Random r = new Random(); + + HighOrderMarkovModel result = new HighOrderMarkovModel(maxOrder, r); + + assertNotNull(result); + assertEquals(r, result.r); + assertEquals(maxOrder + 1, result.trieOrder); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testHighOrderMarkovModel_3() throws Exception { + int maxOrder = 1; + Random r = null; + + new HighOrderMarkovModel(maxOrder, r); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testHighOrderMarkovModel_4() throws Exception { + int maxOrder = -1; + Random r = new Random(); + + new HighOrderMarkovModel(maxOrder, r); + } + + @Test + public void testGetProbability_1() throws Exception { + int markovOrder = 1; + HighOrderMarkovModel fixture = new HighOrderMarkovModel(markovOrder, + new Random()); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(new Event("a")); + + Event symbol = new Event("b"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(2.0d / 5.0, result, 0.0001); + } + + @Test + public void testGetProbability_2() throws Exception { + int markovOrder = 1; + HighOrderMarkovModel fixture = new HighOrderMarkovModel(markovOrder, + new Random()); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(new Event("a")); + + Event symbol = new Event("r"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(0.0d / 5.0, result, 0.0001); + } + + @Test + public void testGetProbability_3() throws Exception { + int markovOrder = 1; + HighOrderMarkovModel fixture = new HighOrderMarkovModel(markovOrder, + new Random()); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(new Event("a")); + + Event symbol = new Event("c"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(1.0d / 5.0, result, 0.0001); + } + + @Test + public void testGetProbability_4() throws Exception { + int markovOrder = 1; + HighOrderMarkovModel fixture = new HighOrderMarkovModel(markovOrder, + new Random()); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(Event.STARTEVENT); + context.add(new Event("a")); + + Event symbol = new Event("b"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(2.0d / 5.0, result, 0.0001); + } + + @Test + public void testGetProbability_5() throws Exception { + int markovOrder = 2; + HighOrderMarkovModel fixture = new HighOrderMarkovModel(markovOrder, + new Random()); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(Event.STARTEVENT); + context.add(new Event("a")); + + Event symbol = new Event("b"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(1.0d, result, 0.0001); + } + + @Test + public void testGetProbability_6() throws Exception { + int markovOrder = 2; + HighOrderMarkovModel fixture = new HighOrderMarkovModel(markovOrder, + new Random()); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(Event.STARTEVENT); + context.add(new Event("b")); + + Event symbol = new Event("b"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(0.0d, result, 0.0001); + } + + @Test + public void testGetProbability_7() throws Exception { + int markovOrder = 0; + HighOrderMarkovModel fixture = new HighOrderMarkovModel(markovOrder, + new Random()); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(Event.STARTEVENT); + context.add(new Event("b")); + + Event symbol = new Event("a"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(5.0d / 13.0, result, 0.0001); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testGetProbability_8() throws Exception { + int markovOrder = 0; + HighOrderMarkovModel fixture = new HighOrderMarkovModel(markovOrder, + new Random()); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(Event.STARTEVENT); + context.add(new Event("b")); + + Event symbol = null; + + fixture.getProbability(context, symbol); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testGetProbability_9() throws Exception { + int markovOrder = 0; + HighOrderMarkovModel fixture = new HighOrderMarkovModel(markovOrder, + new Random()); + fixture.train(sequences); + + List> context = null; + + Event symbol = new Event("b"); + + fixture.getProbability(context, symbol); + } + + @Before + public void setUp() throws Exception { + List> sequence = new ArrayList>(); + sequence.add(new Event("a")); + sequence.add(new Event("b")); + sequence.add(new Event("r")); + sequence.add(new Event("a")); + sequence.add(new Event("c")); + sequence.add(new Event("a")); + sequence.add(new Event("d")); + sequence.add(new Event("a")); + sequence.add(new Event("b")); + sequence.add(new Event("r")); + sequence.add(new Event("a")); + + sequences = new ArrayList>>(); + sequences.add(sequence); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(HighOrderMarkovModelTest.class); + } +} Index: trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/IncompleteMemoryTest.java =================================================================== --- trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/IncompleteMemoryTest.java (revision 518) +++ trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/IncompleteMemoryTest.java (revision 518) @@ -0,0 +1,152 @@ +package de.ugoe.cs.quest.usageprofiles; + +import java.util.ArrayList; +import java.util.List; +import org.junit.*; + +import de.ugoe.cs.quest.usageprofiles.IncompleteMemory; +import static org.junit.Assert.*; + +/** + * The class IncompleteMemoryTest contains tests for the class {@link IncompleteMemory}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class IncompleteMemoryTest { + + @Test + public void testIncompleteMemory_1() + throws Exception { + int length = 1; + + IncompleteMemory result = new IncompleteMemory(length); + + assertNotNull(result); + assertEquals(0, result.getLast(1).size()); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testIncompleteMemory_2() + throws Exception { + int length = 0; + + new IncompleteMemory(length); + } + + @Test + public void testGetLast_1() + throws Exception { + int length = 2; + IncompleteMemory fixture = new IncompleteMemory(length); + fixture.add("1"); + fixture.add("2"); + fixture.add("3"); + int num = -1; + + List result = fixture.getLast(num); + + assertNotNull(result); + assertEquals(0, result.size()); + } + + @Test + public void testGetLast_2() + throws Exception { + int length = 2; + IncompleteMemory fixture = new IncompleteMemory(length); + fixture.add("1"); + fixture.add("2"); + fixture.add("3"); + int num = 1; + + List expected = new ArrayList(); + expected.add("3"); + + List result = fixture.getLast(num); + + assertNotNull(result); + assertEquals(expected, result); + } + + @Test + public void testGetLast_3() + throws Exception { + int length = 2; + IncompleteMemory fixture = new IncompleteMemory(length); + fixture.add("1"); + fixture.add("2"); + fixture.add("3"); + int num = 2; + + List expected = new ArrayList(); + expected.add("2"); + expected.add("3"); + + List result = fixture.getLast(num); + + assertNotNull(result); + assertEquals(expected, result); + } + + @Test + public void testGetLast_4() + throws Exception { + int length = 2; + IncompleteMemory fixture = new IncompleteMemory(length); + fixture.add("1"); + fixture.add("2"); + fixture.add("3"); + int num = 3; + + List expected = new ArrayList(); + expected.add("2"); + expected.add("3"); + + List result = fixture.getLast(num); + + assertNotNull(result); + assertEquals(expected, result); + } + + @Test + public void testGetLength_1() + throws Exception { + int length = 2; + IncompleteMemory fixture = new IncompleteMemory(length); + + int result = fixture.getLength(); + + assertEquals(0, result); + } + + @Test + public void testGetLength_2() + throws Exception { + int length = 2; + IncompleteMemory fixture = new IncompleteMemory(length); + fixture.add("1"); + + int result = fixture.getLength(); + + assertEquals(1, result); + } + + @Test + public void testGetLength_3() + throws Exception { + int length = 2; + IncompleteMemory fixture = new IncompleteMemory(length); + fixture.add("1"); + fixture.add("2"); + fixture.add("3"); + + int result = fixture.getLength(); + + assertEquals(2, result); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(IncompleteMemoryTest.class); + } +} Index: trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/MockTrieBasedModel.java =================================================================== --- trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/MockTrieBasedModel.java (revision 518) +++ trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/MockTrieBasedModel.java (revision 518) @@ -0,0 +1,31 @@ +package de.ugoe.cs.quest.usageprofiles; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +import de.ugoe.cs.quest.eventcore.Event; +import de.ugoe.cs.quest.usageprofiles.TrieBasedModel; + +public class MockTrieBasedModel extends TrieBasedModel { + private static final long serialVersionUID = 1L; + + public MockTrieBasedModel(int markovOrder, Random r) { + super(markovOrder, r); + } + + @Override + public double getProbability(List> context, + Event symbol) { + List> list = new ArrayList>(); + if( context.isEmpty() ) { + return 2; + } + list.add(context.get(context.size()-1)); + if( trie.find(list).getFollowingSymbols().contains(symbol) ) { + return 1; + } else { + return 0; + } + } +} Index: trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/ModelFlattenerTest.java =================================================================== --- trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/ModelFlattenerTest.java (revision 518) +++ trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/ModelFlattenerTest.java (revision 518) @@ -0,0 +1,148 @@ +package de.ugoe.cs.quest.usageprofiles; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Random; +import org.junit.*; + +import de.ugoe.cs.quest.eventcore.Event; +import de.ugoe.cs.quest.usageprofiles.FirstOrderMarkovModel; +import de.ugoe.cs.quest.usageprofiles.HighOrderMarkovModel; +import de.ugoe.cs.quest.usageprofiles.ModelFlattener; +import de.ugoe.cs.quest.usageprofiles.PredictionByPartialMatch; +import de.ugoe.cs.quest.usageprofiles.TrieNode; +import static org.junit.Assert.*; + +/** + * The class ModelFlattenerTest contains tests for the class {@link ModelFlattener}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class ModelFlattenerTest { + + List> sequence; + + private static void assertCollectionContent(Collection c1, Collection c2) { + assertEquals(c1.size(), c2.size()); + for( Object obj : c1 ) { + assertTrue(c2.contains(obj)); + } + } + + @Test + public void testFlattenHighOrderMarkovModel_1() + throws Exception { + ModelFlattener fixture = new ModelFlattener(); + HighOrderMarkovModel model = new HighOrderMarkovModel(2, new Random()); + Collection>> sequences = new ArrayList>>(); + sequences.add(sequence); + model.train(sequences); + + Collection> expectedSymbols = new HashSet>(); + expectedSymbols.add(new Event("a-=-END")); + expectedSymbols.add(new Event("a-=-b")); + expectedSymbols.add(new Event("a-=-c")); + expectedSymbols.add(new Event("a-=-d")); + expectedSymbols.add(new Event("b-=-r")); + expectedSymbols.add(new Event("c-=-a")); + expectedSymbols.add(new Event("d-=-a")); + expectedSymbols.add(new Event("r-=-a")); + expectedSymbols.add(new Event("START-=-a")); + + FirstOrderMarkovModel result = fixture.flattenHighOrderMarkovModel(model); + + assertCollectionContent(expectedSymbols, result.getEvents()); + + TrieNode> root = result.trie.find(null); + TrieNode> root_aEnd = root.getChild(new Event("a-=-END")); + TrieNode> root_ab = root.getChild(new Event("a-=-b")); + TrieNode> root_ab_br = root_ab.getChild(new Event("b-=-r")); + TrieNode> root_ac = root.getChild(new Event("a-=-c")); + TrieNode> root_ac_ca = root_ac.getChild(new Event("c-=-a")); + TrieNode> root_ad = root.getChild(new Event("a-=-d")); + TrieNode> root_ad_da = root_ad.getChild(new Event("d-=-a")); + TrieNode> root_br = root.getChild(new Event("b-=-r")); + TrieNode> root_br_ra = root_br.getChild(new Event("r-=-a")); + TrieNode> root_ca = root.getChild(new Event("c-=-a")); + TrieNode> root_ca_ad = root_ca.getChild(new Event("a-=-d")); + TrieNode> root_da = root.getChild(new Event("d-=-a")); + TrieNode> root_da_ab = root_da.getChild(new Event("a-=-b")); + TrieNode> root_ra = root.getChild(new Event("r-=-a")); + TrieNode> root_ra_ac = root_ra.getChild(new Event ("a-=-c")); + TrieNode> root_ra_aEnd = root_ra.getChild(new Event("a-=-END")); + TrieNode> root_startA = root.getChild(new Event("START-=-a")); + TrieNode> root_startA_ab = root_startA.getChild(new Event("a-=-b")); + + assertEquals(1, root_aEnd.getCount()); + assertTrue(root_aEnd.isLeaf()); + assertEquals(2, root_ab.getCount()); + assertEquals(1, root_ab.getChildren().size()); + assertEquals(2, root_ab_br.getCount()); + assertTrue(root_ab_br.isLeaf()); + assertEquals(1, root_ac.getCount()); + assertEquals(1, root_ac.getChildren().size()); + assertEquals(1, root_ac_ca.getCount()); + assertTrue(root_ac_ca.isLeaf()); + assertEquals(1, root_ad.getCount()); + assertEquals(1, root_ad.getChildren().size()); + assertEquals(1, root_ad_da.getCount()); + assertTrue(root_ad_da.isLeaf()); + assertEquals(2, root_br.getCount()); + assertEquals(1, root_br.getChildren().size()); + assertEquals(2, root_br_ra.getCount()); + assertTrue(root_br_ra.isLeaf()); + assertEquals(1, root_ca.getCount()); + assertEquals(1, root_ca.getChildren().size()); + assertEquals(1, root_ca_ad.getCount()); + assertTrue(root_ca_ad.isLeaf()); + assertEquals(1, root_da.getCount()); + assertEquals(1, root_da.getChildren().size()); + assertEquals(1, root_da_ab.getCount()); + assertTrue(root_da_ab.isLeaf()); + assertEquals(2, root_ra.getCount()); + assertEquals(2, root_ra.getChildren().size()); + assertEquals(1, root_ra_ac.getCount()); + assertTrue(root_ra_ac.isLeaf()); + assertEquals(1, root_ra_aEnd.getCount()); + assertTrue(root_ra_aEnd.isLeaf()); + assertEquals(1, root_startA.getCount()); + assertEquals(1, root_startA.getChildren().size()); + assertEquals(1, root_startA_ab.getCount()); + assertTrue(root_startA_ab.isLeaf()); + } + + @Test + public void testFlattenPredictionByPartialMatch_1() + throws Exception { + ModelFlattener fixture = new ModelFlattener(); + PredictionByPartialMatch model = new PredictionByPartialMatch(1, new Random()); + + FirstOrderMarkovModel result = fixture.flattenPredictionByPartialMatch(model); + + assertEquals(null, result); + } + + @Before + public void setUp() + throws Exception { + sequence = new ArrayList>(); + sequence.add(new Event("a")); + sequence.add(new Event("b")); + sequence.add(new Event("r")); + sequence.add(new Event("a")); + sequence.add(new Event("c")); + sequence.add(new Event("a")); + sequence.add(new Event("d")); + sequence.add(new Event("a")); + sequence.add(new Event("b")); + sequence.add(new Event("r")); + sequence.add(new Event("a")); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(ModelFlattenerTest.class); + } +} Index: trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/PredictionByPartialMatchTest.java =================================================================== --- trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/PredictionByPartialMatchTest.java (revision 518) +++ trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/PredictionByPartialMatchTest.java (revision 518) @@ -0,0 +1,365 @@ +package de.ugoe.cs.quest.usageprofiles; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import de.ugoe.cs.quest.eventcore.Event; +import de.ugoe.cs.quest.usageprofiles.PredictionByPartialMatch; + +import java.util.Random; +import org.junit.*; + +import static org.junit.Assert.*; + +/** + * The class PredictionByPartialMatchTest contains tests for the + * class {@link PredictionByPartialMatch}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class PredictionByPartialMatchTest { + + Collection>> sequences; + + @Test + public void testPredictionByPartialMatch_1() throws Exception { + int markovOrder = 2; + Random r = new Random(); + + PredictionByPartialMatch result = new PredictionByPartialMatch( + markovOrder, r); + + assertNotNull(result); + assertEquals(markovOrder+1, result.trieOrder); + assertEquals(0, result.minOrder); + assertEquals(r, result.r); + assertEquals(0.1, result.probEscape, 0.0001); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testPredictionByPartialMatch_2() throws Exception { + int markovOrder = -1; + Random r = new Random(); + + new PredictionByPartialMatch(markovOrder, r); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testPredictionByPartialMatch_3() throws Exception { + int markovOrder = 2; + Random r = null; + + new PredictionByPartialMatch(markovOrder, r); + } + + @Test + public void testPredictionByPartialMatch_4() throws Exception { + int markovOrder = 2; + Random r = new Random(); + double probEscape = 0.2; + + PredictionByPartialMatch result = new PredictionByPartialMatch( + markovOrder, r, probEscape); + + assertNotNull(result); + assertEquals(markovOrder+1, result.trieOrder); + assertEquals(0, result.minOrder); + assertEquals(r, result.r); + assertEquals(probEscape, result.probEscape, 0.0001); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testPredictionByPartialMatch_5() throws Exception { + int markovOrder = -1; + Random r = new Random(); + double probEscape = 0.2; + + new PredictionByPartialMatch(markovOrder, r, probEscape); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testPredictionByPartialMatch_6() throws Exception { + int markovOrder = 2; + Random r = null; + double probEscape = 0.2; + + new PredictionByPartialMatch(markovOrder, r, probEscape); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testPredictionByPartialMatch_7() throws Exception { + int markovOrder = 2; + Random r = new Random(); + double probEscape = 0.0; + + new PredictionByPartialMatch(markovOrder, r, probEscape); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testPredictionByPartialMatch_8() throws Exception { + int markovOrder = 2; + Random r = new Random(); + double probEscape = 1.0; + + new PredictionByPartialMatch(markovOrder, r, probEscape); + } + + @Test + public void testPredictionByPartialMatch_9() throws Exception { + int markovOrder = 2; + Random r = new Random(); + double probEscape = 0.2; + int minOrder = 1; + + PredictionByPartialMatch result = new PredictionByPartialMatch( + markovOrder, minOrder, r, probEscape); + + assertNotNull(result); + assertEquals(markovOrder+1, result.trieOrder); + assertEquals(minOrder, result.minOrder); + assertEquals(r, result.r); + assertEquals(probEscape, result.probEscape, 0.0001); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testPredictionByPartialMatch_10() throws Exception { + int markovOrder = -1; + Random r = new Random(); + double probEscape = 0.2; + int minOrder = 1; + + new PredictionByPartialMatch(markovOrder, minOrder, r, probEscape); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testPredictionByPartialMatch_11() throws Exception { + int markovOrder = 2; + Random r = null; + double probEscape = 0.2; + int minOrder = 1; + + new PredictionByPartialMatch(markovOrder, minOrder, r, probEscape); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testPredictionByPartialMatch_12() throws Exception { + int markovOrder = 2; + Random r = new Random(); + double probEscape = 0.0; + int minOrder = 1; + + new PredictionByPartialMatch(markovOrder, minOrder, r, probEscape); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testPredictionByPartialMatch_13() throws Exception { + int markovOrder = 2; + Random r = new Random(); + double probEscape = 1.0; + int minOrder = 1; + + new PredictionByPartialMatch(markovOrder, minOrder, r, probEscape); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testPredictionByPartialMatch_14() throws Exception { + int markovOrder = 2; + Random r = new Random(); + double probEscape = 0.2; + int minOrder = 3; + + new PredictionByPartialMatch(markovOrder, minOrder, r, probEscape); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testPredictionByPartialMatch_15() throws Exception { + int markovOrder = 2; + Random r = new Random(); + double probEscape = 0.2; + int minOrder = -1; + + new PredictionByPartialMatch(markovOrder, minOrder, r, probEscape); + } + + @Test + public void testGetProbEscape_1() throws Exception { + int markovOrder = 2; + Random r = new Random(); + double probEscape = 0.2; + int minOrder = 1; + + PredictionByPartialMatch fixture = new PredictionByPartialMatch(markovOrder, minOrder, r, probEscape); + fixture.probEscape = probEscape; + + double result = fixture.getProbEscape(); + + assertEquals(probEscape, result, 0.0001); + } + + @Test + public void testGetProbability_1() throws Exception { + int markovOrder = 2; + Random r = new Random(); + double probEscape = 0.2; + int minOrder = 1; + + PredictionByPartialMatch fixture = new PredictionByPartialMatch(markovOrder, minOrder, r, probEscape); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(Event.STARTEVENT); + context.add(new Event("a")); + + Event symbol = new Event("b"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(0.88d, result, 0.0001); + } + + @Test + public void testGetProbability_2() throws Exception { + int markovOrder = 2; + Random r = new Random(); + double probEscape = 0.2; + int minOrder = 1; + + PredictionByPartialMatch fixture = new PredictionByPartialMatch(markovOrder, minOrder, r, probEscape); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(Event.STARTEVENT); + context.add(new Event("a")); + + Event symbol = new Event("c"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(0.04d, result, 0.0001); + } + + @Test + public void testGetProbability_3() throws Exception { + int markovOrder = 2; + Random r = new Random(); + double probEscape = 0.2; + int minOrder = 2; + + PredictionByPartialMatch fixture = new PredictionByPartialMatch(markovOrder, minOrder, r, probEscape); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(Event.STARTEVENT); + context.add(new Event("a")); + + Event symbol = new Event("b"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(1.0d, result, 0.0001); + } + + @Test + public void testGetProbability_4() throws Exception { + int markovOrder = 2; + Random r = new Random(); + double probEscape = 0.2; + int minOrder = 2; + + PredictionByPartialMatch fixture = new PredictionByPartialMatch(markovOrder, minOrder, r, probEscape); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(Event.STARTEVENT); + context.add(new Event("a")); + + Event symbol = new Event("c"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(0.0d, result, 0.0001); + } + + @Test + public void testGetProbability_5() throws Exception { + int markovOrder = 2; + Random r = new Random(); + double probEscape = 0.2; + int minOrder = 0; + + PredictionByPartialMatch fixture = new PredictionByPartialMatch(markovOrder, minOrder, r, probEscape); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(Event.STARTEVENT); + context.add(new Event("a")); + + Event symbol = new Event("b"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(0.8701d, result, 0.0001); + } + + @Test + public void testGetProbability_6() throws Exception { + int markovOrder = 2; + Random r = new Random(); + double probEscape = 0.2; + int minOrder = 0; + + PredictionByPartialMatch fixture = new PredictionByPartialMatch(markovOrder, minOrder, r, probEscape); + fixture.train(sequences); + + List> context = new ArrayList>(); + context.add(Event.STARTEVENT); + context.add(new Event("a")); + + Event symbol = new Event("c"); + + double result = fixture.getProbability(context, symbol); + + assertEquals(0.0350, result, 0.0001); + } + + @Test + public void testSetProbEscape_1() throws Exception { + int markovOrder = 2; + Random r = new Random(); + double probEscape = 0.2; + int minOrder = 1; + double newProbEscape = 0.3; + + PredictionByPartialMatch fixture = new PredictionByPartialMatch(markovOrder, minOrder, r, probEscape); + + fixture.setProbEscape(newProbEscape); + + assertEquals(newProbEscape, fixture.probEscape, 0.0001); + } + + @Before + public void setUp() throws Exception { + List> sequence = new ArrayList>(); + sequence.add(new Event("a")); + sequence.add(new Event("b")); + sequence.add(new Event("r")); + sequence.add(new Event("a")); + sequence.add(new Event("c")); + sequence.add(new Event("a")); + sequence.add(new Event("d")); + sequence.add(new Event("a")); + sequence.add(new Event("b")); + sequence.add(new Event("r")); + sequence.add(new Event("a")); + + sequences = new ArrayList>>(); + sequences.add(sequence); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore() + .run(PredictionByPartialMatchTest.class); + } +} Index: trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/TrieBasedModelTest.java =================================================================== --- trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/TrieBasedModelTest.java (revision 518) +++ trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/TrieBasedModelTest.java (revision 518) @@ -0,0 +1,635 @@ +package de.ugoe.cs.quest.usageprofiles; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Random; + +import de.ugoe.cs.quest.eventcore.Event; +import de.ugoe.cs.quest.usageprofiles.Trie; +import de.ugoe.cs.quest.usageprofiles.TrieBasedModel; +import de.ugoe.cs.quest.usageprofiles.TrieNode; + +import org.junit.*; +import static org.junit.Assert.*; + +/** + * The class TrieBasedModelTest contains tests for the class + * {@link TrieBasedModel}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class TrieBasedModelTest { + + List> sequence; + Collection> symbols; + + private void assertTrieStructure(Trie> trie, int numSequences) { + TrieNode> root = trie.find(null); + TrieNode> root_a = root.getChild(new Event("a")); + TrieNode> root_a_a = root_a.getChild(new Event("a")); + TrieNode> root_a_b = root_a.getChild(new Event("b")); + TrieNode> root_a_b_a = root_a_b + .getChild(new Event("a")); + TrieNode> root_a_b_b = root_a_b + .getChild(new Event("b")); + TrieNode> root_a_b_c = root_a_b + .getChild(new Event("c")); + TrieNode> root_a_b_d = root_a_b + .getChild(new Event("d")); + TrieNode> root_a_b_r = root_a_b + .getChild(new Event("r")); + TrieNode> root_a_c = root_a.getChild(new Event("c")); + TrieNode> root_a_c_a = root_a_c + .getChild(new Event("a")); + TrieNode> root_a_c_b = root_a_c + .getChild(new Event("b")); + TrieNode> root_a_c_c = root_a_c + .getChild(new Event("c")); + TrieNode> root_a_c_d = root_a_c + .getChild(new Event("d")); + TrieNode> root_a_c_r = root_a_c + .getChild(new Event("r")); + TrieNode> root_a_d = root_a.getChild(new Event("d")); + TrieNode> root_a_d_a = root_a_d + .getChild(new Event("a")); + TrieNode> root_a_d_b = root_a_d + .getChild(new Event("b")); + TrieNode> root_a_d_c = root_a_d + .getChild(new Event("c")); + TrieNode> root_a_d_d = root_a_d + .getChild(new Event("d")); + TrieNode> root_a_d_r = root_a_d + .getChild(new Event("r")); + TrieNode> root_a_r = root_a.getChild(new Event("r")); + TrieNode> root_b = root.getChild(new Event("b")); + TrieNode> root_b_a = root_b.getChild(new Event("a")); + TrieNode> root_b_b = root_b.getChild(new Event("b")); + TrieNode> root_b_c = root_b.getChild(new Event("c")); + TrieNode> root_b_d = root_b.getChild(new Event("d")); + TrieNode> root_b_r = root_b.getChild(new Event("r")); + TrieNode> root_b_r_a = root_b_r + .getChild(new Event("a")); + TrieNode> root_b_r_b = root_b_r + .getChild(new Event("b")); + TrieNode> root_b_r_c = root_b_r + .getChild(new Event("c")); + TrieNode> root_b_r_d = root_b_r + .getChild(new Event("d")); + TrieNode> root_b_r_r = root_b_r + .getChild(new Event("r")); + TrieNode> root_c = root.getChild(new Event("c")); + TrieNode> root_c_a = root_c.getChild(new Event("a")); + TrieNode> root_c_a_a = root_c_a + .getChild(new Event("a")); + TrieNode> root_c_a_b = root_c_a + .getChild(new Event("b")); + TrieNode> root_c_a_c = root_c_a + .getChild(new Event("c")); + TrieNode> root_c_a_d = root_c_a + .getChild(new Event("d")); + TrieNode> root_c_a_r = root_c_a + .getChild(new Event("r")); + TrieNode> root_c_b = root_c.getChild(new Event("b")); + TrieNode> root_c_c = root_c.getChild(new Event("c")); + TrieNode> root_c_d = root_c.getChild(new Event("d")); + TrieNode> root_c_r = root_c.getChild(new Event("r")); + TrieNode> root_d = root.getChild(new Event("d")); + TrieNode> root_d_a = root_d.getChild(new Event("a")); + TrieNode> root_d_a_a = root_d_a + .getChild(new Event("a")); + TrieNode> root_d_a_b = root_d_a + .getChild(new Event("b")); + TrieNode> root_d_a_c = root_d_a + .getChild(new Event("c")); + TrieNode> root_d_a_d = root_d_a + .getChild(new Event("d")); + TrieNode> root_d_a_r = root_d_a + .getChild(new Event("r")); + TrieNode> root_d_b = root_d.getChild(new Event("b")); + TrieNode> root_d_c = root_d.getChild(new Event("c")); + TrieNode> root_d_d = root_d.getChild(new Event("d")); + TrieNode> root_d_r = root_d.getChild(new Event("r")); + TrieNode> root_r = root.getChild(new Event("r")); + TrieNode> root_r_a = root_r.getChild(new Event("a")); + TrieNode> root_r_a_a = root_r_a + .getChild(new Event("a")); + TrieNode> root_r_a_b = root_r_a + .getChild(new Event("b")); + TrieNode> root_r_a_c = root_r_a + .getChild(new Event("c")); + TrieNode> root_r_a_d = root_r_a + .getChild(new Event("d")); + TrieNode> root_r_a_r = root_r_a + .getChild(new Event("r")); + TrieNode> root_r_a_end = root_r_a.getChild(Event.ENDEVENT); + TrieNode> root_r_b = root_r.getChild(new Event("b")); + TrieNode> root_r_c = root_r.getChild(new Event("c")); + TrieNode> root_r_d = root_r.getChild(new Event("d")); + TrieNode> root_r_r = root_r.getChild(new Event("r")); + TrieNode> root_start = root.getChild(Event.STARTEVENT); + TrieNode> root_start_a = root_start + .getChild(new Event("a")); + TrieNode> root_start_a_a = root_start_a + .getChild(new Event("a")); + TrieNode> root_start_a_b = root_start_a + .getChild(new Event("b")); + TrieNode> root_start_a_c = root_start_a + .getChild(new Event("c")); + TrieNode> root_start_a_d = root_start_a + .getChild(new Event("d")); + TrieNode> root_start_a_r = root_start_a + .getChild(new Event("r")); + TrieNode> root_start_b = root_start + .getChild(new Event("b")); + TrieNode> root_start_c = root_start + .getChild(new Event("c")); + TrieNode> root_start_d = root_start + .getChild(new Event("d")); + TrieNode> root_start_r = root_start + .getChild(new Event("r")); + + assertEquals(numSequences * 5, root_a.getCount()); + assertNull(root_a_a); + assertEquals(numSequences * 2, root_a_b.getCount()); + assertNull(root_a_b_a); + assertNull(root_a_b_b); + assertNull(root_a_b_c); + assertNull(root_a_b_d); + assertEquals(numSequences * 2, root_a_b_r.getCount()); + assertEquals(numSequences * 1, root_a_c.getCount()); + assertEquals(numSequences * 1, root_a_c_a.getCount()); + assertNull(root_a_c_b); + assertNull(root_a_c_c); + assertNull(root_a_c_d); + assertNull(root_a_c_r); + assertEquals(numSequences * 1, root_a_d.getCount()); + assertEquals(numSequences * 1, root_a_d_a.getCount()); + assertNull(root_a_d_b); + assertNull(root_a_d_c); + assertNull(root_a_d_d); + assertNull(root_a_d_r); + assertNull(root_a_r); + + assertEquals(numSequences * 2, root_b.getCount()); + assertNull(root_b_a); + assertNull(root_b_b); + assertNull(root_b_c); + assertNull(root_b_d); + assertEquals(numSequences * 2, root_b_r.getCount()); + assertEquals(numSequences * 2, root_b_r_a.getCount()); + assertNull(root_b_r_b); + assertNull(root_b_r_c); + assertNull(root_b_r_d); + assertNull(root_b_r_r); + + assertEquals(numSequences * 1, root_c.getCount()); + assertEquals(numSequences * 1, root_c_a.getCount()); + assertNull(root_c_a_a); + assertNull(root_c_a_b); + assertNull(root_c_a_c); + assertEquals(numSequences * 1, root_c_a_d.getCount()); + assertNull(root_c_a_r); + assertNull(root_c_b); + assertNull(root_c_c); + assertNull(root_c_d); + assertNull(root_c_r); + + assertEquals(numSequences * 1, root_d.getCount()); + assertEquals(numSequences * 1, root_d_a.getCount()); + assertNull(root_d_a_a); + assertEquals(numSequences * 1, root_d_a_b.getCount()); + assertNull(root_d_a_c); + assertNull(root_d_a_d); + assertNull(root_d_a_r); + assertNull(root_d_b); + assertNull(root_d_c); + assertNull(root_d_d); + assertNull(root_d_r); + + assertEquals(numSequences * 2, root_r.getCount()); + assertEquals(numSequences * 2, root_r_a.getCount()); + assertNull(root_r_a_a); + assertNull(root_r_a_b); + assertEquals(numSequences * 1, root_r_a_c.getCount()); + assertNull(root_r_a_d); + assertNull(root_r_a_r); + assertEquals(numSequences * 1, root_r_a_end.getCount()); + assertNull(root_r_b); + assertNull(root_r_c); + assertNull(root_r_d); + assertNull(root_r_r); + + assertEquals(numSequences * 1, root_start.getCount()); + assertEquals(numSequences * 1, root_start_a.getCount()); + assertNull(root_start_a_a); + assertEquals(numSequences * 1, root_start_a_b.getCount()); + assertNull(root_start_a_c); + assertNull(root_start_a_d); + assertNull(root_start_a_r); + assertNull(root_start_b); + assertNull(root_start_c); + assertNull(root_start_d); + assertNull(root_start_r); + + // check if leafs are really leafs + assertTrue(root_a_b_r.isLeaf()); + assertTrue(root_a_c_a.isLeaf()); + assertTrue(root_a_d_a.isLeaf()); + assertTrue(root_b_r_a.isLeaf()); + assertTrue(root_c_a_d.isLeaf()); + assertTrue(root_d_a_b.isLeaf()); + assertTrue(root_r_a_c.isLeaf()); + assertTrue(root_r_a_end.isLeaf()); + } + + private static void assertCollectionContent(Collection c1, + Collection c2) { + assertEquals(c1.size(), c2.size()); + for (Object obj : c1) { + assertTrue(c2.contains(obj)); + } + } + + @Test + public void testTrieBasedModel_1() throws Exception { + int markovOrder = 2; + Random r = new Random(); + + MockTrieBasedModel result = new MockTrieBasedModel(markovOrder, r); + + assertNotNull(result); + assertEquals(markovOrder + 1, result.trieOrder); + assertEquals(r, result.r); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testTrieBasedModel_2() throws Exception { + int markovOrder = -1; + Random r = new Random(); + + new MockTrieBasedModel(markovOrder, r); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testTrieBasedModel_3() throws Exception { + int markovOrder = 2; + Random r = null; + + new MockTrieBasedModel(markovOrder, r); + } + + @Test + public void testGenerateSequences_1() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + Collection>> sequences = new ArrayList>>(); + sequences.add(sequence); + fixture.train(sequences); + int length = 2; + + Collection>> expected = new HashSet>>(); + ArrayList> list; + list = new ArrayList>(); + list.add(new Event("a")); + list.add(Event.ENDEVENT); + expected.add(list); + list = new ArrayList>(); + list.add(new Event("a")); + list.add(new Event("b")); + expected.add(list); + list = new ArrayList>(); + list.add(new Event("a")); + list.add(new Event("c")); + expected.add(list); + list = new ArrayList>(); + list.add(new Event("a")); + list.add(new Event("d")); + expected.add(list); + list = new ArrayList>(); + list.add(new Event("b")); + list.add(new Event("r")); + expected.add(list); + list = new ArrayList>(); + list.add(new Event("c")); + list.add(new Event("a")); + expected.add(list); + list = new ArrayList>(); + list.add(new Event("d")); + list.add(new Event("a")); + expected.add(list); + list = new ArrayList>(); + list.add(new Event("r")); + list.add(new Event("a")); + expected.add(list); + list = new ArrayList>(); + list.add(Event.STARTEVENT); + list.add(new Event("a")); + expected.add(list); + + Collection>> result = fixture + .generateSequences(length); + + assertCollectionContent(expected, result); + } + + @Test + public void testGenerateSequences_2() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + Collection>> sequences = new ArrayList>>(); + sequences.add(sequence); + fixture.train(sequences); + int length = 3; + + Collection>> expected = new HashSet>>(); + ArrayList> list; + list = new ArrayList>(); + list.add(Event.STARTEVENT); + list.add(new Event("a")); + list.add(Event.ENDEVENT); + expected.add(list); + list = new ArrayList>(); + list.add(Event.STARTEVENT); + list.add(new Event("a")); + list.add(new Event("b")); + expected.add(list); + list = new ArrayList>(); + list.add(Event.STARTEVENT); + list.add(new Event("a")); + list.add(new Event("c")); + expected.add(list); + list = new ArrayList>(); + list.add(Event.STARTEVENT); + list.add(new Event("a")); + list.add(new Event("d")); + expected.add(list); + + Collection>> result = fixture + .generateSequences(length, true); + + assertCollectionContent(expected, result); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testGenerateSequences_3() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + Collection>> sequences = new ArrayList>>(); + sequences.add(sequence); + fixture.train(sequences); + int length = 0; + + fixture.generateSequences(length, false); + } + + @Test + public void testGenerateValidSequences_1() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + Collection>> sequences = new ArrayList>>(); + sequences.add(sequence); + fixture.train(sequences); + int length = 5; + + Collection>> expected = new HashSet>>(); + ArrayList> list; + list = new ArrayList>(); + list.add(Event.STARTEVENT); + list.add(new Event("a")); + list.add(new Event("c")); + list.add(new Event("a")); + list.add(Event.ENDEVENT); + expected.add(list); + list = new ArrayList>(); + list.add(Event.STARTEVENT); + list.add(new Event("a")); + list.add(new Event("d")); + list.add(new Event("a")); + list.add(Event.ENDEVENT); + expected.add(list); + + Collection>> result = fixture + .generateValidSequences(length); + + assertCollectionContent(expected, result); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testGenerateValidSequences_2() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + Collection>> sequences = new ArrayList>>(); + sequences.add(sequence); + fixture.train(sequences); + int length = 0; + + fixture.generateValidSequences(length); + } + + @Test + public void testGetEvents_1() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + Collection>> sequences = new ArrayList>>(); + sequences.add(sequence); + + fixture.train(sequences); + + Collection> result = fixture.getEvents(); + + assertCollectionContent(symbols, result); + } + + @Test + public void testGetEvents_2() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + + Collection> result = fixture.getEvents(); + + assertCollectionContent(new HashSet>(), result); + } + + @Test + public void testGetNumFOMStates_1() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + Collection>> sequences = new ArrayList>>(); + sequences.add(sequence); + + fixture.train(sequences); + + int result = fixture.getNumFOMStates(); + + assertEquals(10, result); + } + + @Test + public void testGetNumFOMStates_2() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + ; + + int result = fixture.getNumFOMStates(); + + assertEquals(0, result); + } + + @Test + public void testGetNumSymbols_1() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + Collection>> sequences = new ArrayList>>(); + sequences.add(sequence); + fixture.train(sequences); + + int result = fixture.getNumSymbols(); + + assertEquals(7, result); + } + + @Test + public void testGetNumSymbols_2() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + + int result = fixture.getNumSymbols(); + + assertEquals(0, result); + } + + @Test + public void testGetNumTransitions_1() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + Collection>> sequences = new ArrayList>>(); + sequences.add(sequence); + fixture.train(sequences); + + int result = fixture.getNumTransitions(); + + assertEquals(11, result); + } + + @Test + public void testGetNumTransitions_2() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + + int result = fixture.getNumTransitions(); + + assertEquals(0, result); + } + + @Test + public void testTrain_1() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + Collection>> sequences = new ArrayList>>(); + sequences.add(sequence); + + fixture.train(sequences); + + assertCollectionContent(symbols, fixture.getEvents()); + + assertTrieStructure(fixture.trie, 1); + } + + @Test + public void testTrain_2() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + Collection>> sequences = new ArrayList>>(); + sequences.add(sequence); + sequences.add(sequence); + + fixture.train(sequences); + + assertCollectionContent(symbols, fixture.getEvents()); + + assertTrieStructure(fixture.trie, 2); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testTrain_3() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + Collection>> sequences = null; + + fixture.train(sequences); + } + + @Test + public void testUpdate_1() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + Collection>> sequences = new ArrayList>>(); + sequences.add(sequence); + fixture.train(sequences); + + fixture.update(sequences); + + assertCollectionContent(symbols, fixture.getEvents()); + assertTrieStructure(fixture.trie, 2); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testUpdate_2() throws Exception { + int markovOrder = 2; + MockTrieBasedModel fixture = new MockTrieBasedModel(markovOrder, + new Random()); + Collection>> sequences = null; + fixture.trie = null; + + fixture.update(sequences); + } + + @Before + public void setUp() throws Exception { + sequence = new ArrayList>(); + sequence.add(new Event("a")); + sequence.add(new Event("b")); + sequence.add(new Event("r")); + sequence.add(new Event("a")); + sequence.add(new Event("c")); + sequence.add(new Event("a")); + sequence.add(new Event("d")); + sequence.add(new Event("a")); + sequence.add(new Event("b")); + sequence.add(new Event("r")); + sequence.add(new Event("a")); + + symbols = new HashSet>(); + symbols.add(new Event("a")); + symbols.add(new Event("b")); + symbols.add(new Event("c")); + symbols.add(new Event("d")); + symbols.add(new Event("r")); + symbols.add(Event.STARTEVENT); + symbols.add(Event.ENDEVENT); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(TrieBasedModelTest.class); + } +} Index: trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/TrieTest.java =================================================================== --- trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/TrieTest.java (revision 518) +++ trunk/quest-core-usageprofiles-test/src/test/java/de/ugoe/cs/quest/usageprofiles/TrieTest.java (revision 518) @@ -0,0 +1,727 @@ +package de.ugoe.cs.quest.usageprofiles; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; + +import junitx.framework.ListAssert; + +import org.junit.*; + +import de.ugoe.cs.quest.usageprofiles.Trie; +import de.ugoe.cs.quest.usageprofiles.TrieNode; +import de.ugoe.cs.quest.usageprofiles.Trie.Edge; +import de.ugoe.cs.quest.usageprofiles.Trie.TrieVertex; +import static org.junit.Assert.*; + +/** + * The class TrieTest contains tests for the class + * {@link Trie}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class TrieTest { + + List sequence; + Collection symbols; + + private static void assertCollectionContent(Collection c1, + Collection c2) { + assertEquals(c1.size(), c2.size()); + for (Object obj : c1) { + assertTrue(c2.contains(obj)); + } + } + + @Test + public void testTrie_1() throws Exception { + + Trie result = new Trie(); + + assertNotNull(result); + assertEquals(0, result.getNumLeafs()); + assertEquals(0, result.getNumSymbols()); + assertEquals(0, result.getNumLeafAncestors()); + assertTrue(result.getKnownSymbols().isEmpty()); + } + + @Test + public void testTrie_2() throws Exception { + Trie trie1 = new Trie(); + trie1.train(sequence, 3); + + Trie result = new Trie(trie1); + + assertEquals(trie1, result); + assertNotSame(trie1, result); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testTrie_3() throws Exception { + new Trie(null); + } + + @Test + public void testAdd_1() throws Exception { + Trie fixture = new Trie(); + List seq = new ArrayList(); + seq.add("a"); + seq.add("b"); + + fixture.add(seq); + + assertEquals(1, fixture.getChild("a").getCount()); + assertEquals(1, fixture.getChild("a").getChild("b").getCount()); + assertNull(fixture.getChild("b")); + } + + @Test + public void testAdd_2() throws Exception { + Trie fixture = new Trie(); + + fixture.add(new ArrayList()); + + assertEquals(0, fixture.getNumSymbols()); + } + + @Test + public void testAdd_3() throws Exception { + Trie fixture = new Trie(); + + fixture.add(null); + + assertEquals(0, fixture.getNumSymbols()); + } + + @Test + public void testFind_1() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + List findSequence = new ArrayList(); + findSequence.add("a"); + findSequence.add("b"); + findSequence.add("r"); + TrieNode expected = fixture.getChild("a").getChild("b") + .getChild("r"); + + TrieNode result = fixture.find(findSequence); + + assertEquals(expected, result); + } + + @Test + public void testFind_2() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + List findSequence = new ArrayList(); + findSequence.add("c"); + findSequence.add("a"); + TrieNode expected = fixture.getChild("c").getChild("a"); + + TrieNode result = fixture.find(findSequence); + + assertEquals(expected, result); + } + + @Test + public void testFind_3() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + List findSequence = new ArrayList(); + + TrieNode result = fixture.find(findSequence); + + assertTrue(result.isRoot()); + } + + @Test + public void testFind_4() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + + TrieNode result = fixture.find(null); + + assertTrue(result.isRoot()); + } + + @Test + public void testGetChildCreate_1() throws Exception { + Trie fixture = new Trie(); + String symbol = "a"; + + TrieNode result = fixture.getChildCreate(symbol); + + assertEquals(symbol, result.getSymbol()); + assertEquals(0, result.getCount()); + assertTrue(result.isLeaf()); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testGetChildCreate_2() throws Exception { + Trie fixture = new Trie(); + fixture.getChildCreate(null); + } + + @Test + public void testGetContextSuffix_1() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + List context = new ArrayList(); + context.add("a"); + context.add("a"); + context.add("b"); + List expected = new ArrayList(); + expected.add("a"); + expected.add("b"); + + List result = fixture.getContextSuffix(context); + + ListAssert.assertEquals(expected, result); + } + + @Test + public void testGetContextSuffix_2() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + List context = new ArrayList(); + context.add("a"); + context.add("a"); + context.add("b"); + context.add("r"); + List expected = new ArrayList(); + expected.add("b"); + expected.add("r"); + + List result = fixture.getContextSuffix(context); + + ListAssert.assertEquals(expected, result); + } + + @Test + public void testGetContextSuffix_3() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + List context = new ArrayList(); + context.add("a"); + context.add("a"); + context.add("b"); + context.add("x"); + List expected = new ArrayList(); + + List result = fixture.getContextSuffix(context); + + ListAssert.assertEquals(expected, result); + } + + @Test + public void testGetContextSuffix_4() throws Exception { + Trie fixture = new Trie(); + + List result = fixture.getContextSuffix(null); + + // add additional test code here + assertNotNull(result); + assertEquals(0, result.size()); + } + + @Test + public void testGetContextSuffix_5() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + List context = new ArrayList(); + context.add("a"); + context.add("a"); + context.add("b"); + List expected = new ArrayList(); + expected.add("a"); + expected.add("b"); + + List result = fixture.getContextSuffix(context); + + ListAssert.assertEquals(expected, result); + } + + @Test + public void testGetCount_1() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + List subSequence = new ArrayList(); + subSequence.add("a"); + + int result = fixture.getCount(subSequence); + + assertEquals(5, result); + } + + @Test + public void testGetCount_2() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + List subSequence = new ArrayList(); + subSequence.add("a"); + subSequence.add("b"); + + int result = fixture.getCount(subSequence); + + assertEquals(2, result); + } + + @Test + public void testGetCount_3() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + List subSequence = new ArrayList(); + subSequence.add("x"); + + int result = fixture.getCount(subSequence); + + assertEquals(0, result); + } + + @Test + public void testGetCount_4() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + List subSequence = new ArrayList(); + + int result = fixture.getCount(subSequence, "a"); + + assertEquals(5, result); + } + + @Test + public void testGetCount_5() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + List subSequence = new ArrayList(); + subSequence.add("a"); + subSequence.add("b"); + + int result = fixture.getCount(subSequence, "r"); + + assertEquals(2, result); + } + + @Test + public void testGetCount_6() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + List subSequence = new ArrayList(); + + int result = fixture.getCount(subSequence, "x"); + + assertEquals(0, result); + } + + @Test + public void testGetFollowingSymbols_1() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + List subSequence = new ArrayList(); + subSequence.add("a"); + Collection expected = new ArrayList(); + expected.add("b"); + expected.add("c"); + expected.add("d"); + + Collection result = fixture.getFollowingSymbols(subSequence); + + assertCollectionContent(expected, result); + } + + @Test + public void testGetFollowingSymbols_2() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + List subSequence = new ArrayList(); + subSequence.add("a"); + subSequence.add("b"); + subSequence.add("r"); + + Collection result = fixture.getFollowingSymbols(subSequence); + + assertEquals(0, result.size()); + } + + @Test + public void testGetFollowingSymbols_3() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + List subSequence = new ArrayList(); + subSequence.add("x"); + + Collection result = fixture.getFollowingSymbols(subSequence); + + assertEquals(0, result.size()); + } + + @Test + public void testGetNumLeafAncestors_1() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + + int result = fixture.getNumLeafAncestors(); + + assertEquals(7, result); + } + + @Test + public void testGetNumLeafs_1() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + + int result = fixture.getNumLeafs(); + + assertEquals(7, result); + } + + @Test + public void testGetNumSymbols_1() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 3); + + int result = fixture.getNumSymbols(); + + assertEquals(5, result); + } + + @Test + public void testTrain_1() throws Exception { + Trie fixture = new Trie(); + int maxOrder = 3; + + fixture.train(sequence, maxOrder); + + // check if symbols are correct + assertCollectionContent(symbols, fixture.getKnownSymbols()); + + // check if counters are correct and only the correct nodes exist + TrieNode root = fixture.find(new ArrayList()); + TrieNode root_a = root.getChild("a"); + TrieNode root_a_a = root_a.getChild("a"); + TrieNode root_a_b = root_a.getChild("b"); + TrieNode root_a_b_a = root_a_b.getChild("a"); + TrieNode root_a_b_b = root_a_b.getChild("b"); + TrieNode root_a_b_c = root_a_b.getChild("c"); + TrieNode root_a_b_d = root_a_b.getChild("d"); + TrieNode root_a_b_r = root_a_b.getChild("r"); + TrieNode root_a_c = root_a.getChild("c"); + TrieNode root_a_c_a = root_a_c.getChild("a"); + TrieNode root_a_c_b = root_a_c.getChild("b"); + TrieNode root_a_c_c = root_a_c.getChild("c"); + TrieNode root_a_c_d = root_a_c.getChild("d"); + TrieNode root_a_c_r = root_a_c.getChild("r"); + TrieNode root_a_d = root_a.getChild("d"); + TrieNode root_a_d_a = root_a_d.getChild("a"); + TrieNode root_a_d_b = root_a_d.getChild("b"); + TrieNode root_a_d_c = root_a_d.getChild("c"); + TrieNode root_a_d_d = root_a_d.getChild("d"); + TrieNode root_a_d_r = root_a_d.getChild("r"); + TrieNode root_a_r = root_a.getChild("r"); + TrieNode root_b = root.getChild("b"); + TrieNode root_b_a = root_b.getChild("a"); + TrieNode root_b_b = root_b.getChild("b"); + TrieNode root_b_c = root_b.getChild("c"); + TrieNode root_b_d = root_b.getChild("d"); + TrieNode root_b_r = root_b.getChild("r"); + TrieNode root_b_r_a = root_b_r.getChild("a"); + TrieNode root_b_r_b = root_b_r.getChild("b"); + TrieNode root_b_r_c = root_b_r.getChild("c"); + TrieNode root_b_r_d = root_b_r.getChild("d"); + TrieNode root_b_r_r = root_b_r.getChild("r"); + TrieNode root_c = root.getChild("c"); + TrieNode root_c_a = root_c.getChild("a"); + TrieNode root_c_a_a = root_c_a.getChild("a"); + TrieNode root_c_a_b = root_c_a.getChild("b"); + TrieNode root_c_a_c = root_c_a.getChild("c"); + TrieNode root_c_a_d = root_c_a.getChild("d"); + TrieNode root_c_a_r = root_c_a.getChild("r"); + TrieNode root_c_b = root_c.getChild("b"); + TrieNode root_c_c = root_c.getChild("c"); + TrieNode root_c_d = root_c.getChild("d"); + TrieNode root_c_r = root_c.getChild("r"); + TrieNode root_d = root.getChild("d"); + TrieNode root_d_a = root_d.getChild("a"); + TrieNode root_d_a_a = root_d_a.getChild("a"); + TrieNode root_d_a_b = root_d_a.getChild("b"); + TrieNode root_d_a_c = root_d_a.getChild("c"); + TrieNode root_d_a_d = root_d_a.getChild("d"); + TrieNode root_d_a_r = root_d_a.getChild("r"); + TrieNode root_d_b = root_d.getChild("b"); + TrieNode root_d_c = root_d.getChild("c"); + TrieNode root_d_d = root_d.getChild("d"); + TrieNode root_d_r = root_d.getChild("r"); + TrieNode root_r = root.getChild("r"); + TrieNode root_r_a = root_r.getChild("a"); + TrieNode root_r_a_a = root_r_a.getChild("a"); + TrieNode root_r_a_b = root_r_a.getChild("b"); + TrieNode root_r_a_c = root_r_a.getChild("c"); + TrieNode root_r_a_d = root_r_a.getChild("d"); + TrieNode root_r_a_r = root_r_a.getChild("r"); + TrieNode root_r_b = root_r.getChild("b"); + TrieNode root_r_c = root_r.getChild("c"); + TrieNode root_r_d = root_r.getChild("d"); + TrieNode root_r_r = root_r.getChild("r"); + + assertEquals(5, root_a.getCount()); + assertNull(root_a_a); + assertEquals(2, root_a_b.getCount()); + assertNull(root_a_b_a); + assertNull(root_a_b_b); + assertNull(root_a_b_c); + assertNull(root_a_b_d); + assertEquals(2, root_a_b_r.getCount()); + assertEquals(1, root_a_c.getCount()); + assertEquals(1, root_a_c_a.getCount()); + assertNull(root_a_c_b); + assertNull(root_a_c_c); + assertNull(root_a_c_d); + assertNull(root_a_c_r); + assertEquals(1, root_a_d.getCount()); + assertEquals(1, root_a_d_a.getCount()); + assertNull(root_a_d_b); + assertNull(root_a_d_c); + assertNull(root_a_d_d); + assertNull(root_a_d_r); + assertNull(root_a_r); + + assertEquals(2, root_b.getCount()); + assertNull(root_b_a); + assertNull(root_b_b); + assertNull(root_b_c); + assertNull(root_b_d); + assertEquals(2, root_b_r.getCount()); + assertEquals(2, root_b_r_a.getCount()); + assertNull(root_b_r_b); + assertNull(root_b_r_c); + assertNull(root_b_r_d); + assertNull(root_b_r_r); + + assertEquals(1, root_c.getCount()); + assertEquals(1, root_c_a.getCount()); + assertNull(root_c_a_a); + assertNull(root_c_a_b); + assertNull(root_c_a_c); + assertEquals(1, root_c_a_d.getCount()); + assertNull(root_c_a_r); + assertNull(root_c_b); + assertNull(root_c_c); + assertNull(root_c_d); + assertNull(root_c_r); + + assertEquals(1, root_d.getCount()); + assertEquals(1, root_d_a.getCount()); + assertNull(root_d_a_a); + assertEquals(1, root_d_a_b.getCount()); + assertNull(root_d_a_c); + assertNull(root_d_a_d); + assertNull(root_d_a_r); + assertNull(root_d_b); + assertNull(root_d_c); + assertNull(root_d_d); + assertNull(root_d_r); + + assertEquals(2, root_r.getCount()); + assertEquals(2, root_r_a.getCount()); + assertNull(root_r_a_a); + assertNull(root_r_a_b); + assertEquals(1, root_r_a_c.getCount()); + assertNull(root_r_a_d); + assertNull(root_r_a_r); + assertNull(root_r_b); + assertNull(root_r_c); + assertNull(root_r_d); + assertNull(root_r_r); + + // check if leafs are really leafs + assertTrue(root_a_b_r.isLeaf()); + assertTrue(root_a_c_a.isLeaf()); + assertTrue(root_a_d_a.isLeaf()); + assertTrue(root_b_r_a.isLeaf()); + assertTrue(root_c_a_d.isLeaf()); + assertTrue(root_d_a_b.isLeaf()); + assertTrue(root_r_a_c.isLeaf()); + } + + @Test + public void testTrain_2() throws Exception { + Trie fixture = new Trie(); + int maxOrder = 0; + + fixture.train(sequence, maxOrder); + + assertTrue(fixture.getKnownSymbols().isEmpty()); + } + + @Test + public void testTrain_3() throws Exception { + Trie fixture = new Trie(); + List sequence = new ArrayList(); + int maxOrder = 1; + + fixture.train(sequence, maxOrder); + + assertTrue(fixture.getKnownSymbols().isEmpty()); + } + + @Test + public void testTrain_4() throws Exception { + Trie fixture = new Trie(); + List sequence = new ArrayList(); + sequence.add("a"); + sequence.add("b"); + int maxOrder = 3; + + fixture.train(sequence, maxOrder); + + assertCollectionContent(sequence, fixture.getKnownSymbols()); + TrieNode root = fixture.find(new ArrayList()); + TrieNode root_a = root.getChild("a"); + TrieNode root_a_a = root_a.getChild("a"); + TrieNode root_a_b = root_a.getChild("b"); + TrieNode root_b = root.getChild("b"); + TrieNode root_b_a = root_b.getChild("a"); + TrieNode root_b_b = root_b.getChild("b"); + + assertEquals(1, root_a.getCount()); + assertNull(root_a_a); + assertEquals(1, root_a_b.getCount()); + assertEquals(1, root_b.getCount()); + assertNull(root_b_a); + assertNull(root_b_b); + + assertTrue(root_a_b.isLeaf()); + assertTrue(root_b.isLeaf()); + } + + @Test + public void testEdgeEdge_1() throws Exception { + Edge result = new Edge(); + + assertNotNull(result); + } + + @Test + public void testTrieVertexTrieVertex_1() throws Exception { + String id = "idString"; + + TrieVertex result = new TrieVertex(id); + + assertNotNull(result); + } + + @Test + public void testTrieVertexToString_1() throws Exception { + String id = "idString"; + TrieVertex fixture = new TrieVertex(id); + + String result = fixture.toString(); + + assertEquals(id, result); + } + + @Test + public void testEquals_1() throws Exception { + Trie trieOther = new Trie(); + Trie fixture = new Trie(); + + boolean result = fixture.equals(trieOther); + + assertEquals(true, result); + } + + @Test + public void testEquals_2() throws Exception { + Trie trieOther = new Trie(); + trieOther.train(sequence, 2); + Trie fixture = new Trie(); + fixture.train(sequence, 2); + + boolean result = fixture.equals(trieOther); + + assertEquals(true, result); + } + + @Test + public void testEquals_3() throws Exception { + Trie trieOther = new Trie(); + trieOther.train(sequence, 2); + Trie fixture = new Trie(); + fixture.train(sequence, 3); + + boolean result = fixture.equals(trieOther); + + assertEquals(false, result); + } + + @Test + public void testEquals_4() throws Exception { + Trie trieOther = new Trie(); + Trie fixture = new Trie(); + fixture.train(sequence, 2); + + boolean result = fixture.equals(trieOther); + + assertEquals(false, result); + } + + @Test + public void testEquals_5() throws Exception { + Trie trieOther = new Trie(); + trieOther.train(sequence, 2); + Trie fixture = new Trie(); + + boolean result = fixture.equals(trieOther); + + assertEquals(false, result); + } + + @Test + public void testEquals_6() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 2); + + boolean result = fixture.equals(fixture); + + assertEquals(true, result); + } + + @Test + public void testEquals_7() throws Exception { + Trie fixture = new Trie(); + fixture.train(sequence, 2); + + boolean result = fixture.equals(null); + + assertEquals(false, result); + } + + @Before + public void setUp() throws Exception { + sequence = new ArrayList(); + sequence.add("a"); + sequence.add("b"); + sequence.add("r"); + sequence.add("a"); + sequence.add("c"); + sequence.add("a"); + sequence.add("d"); + sequence.add("a"); + sequence.add("b"); + sequence.add("r"); + sequence.add("a"); + + symbols = new HashSet(); + symbols.add("a"); + symbols.add("b"); + symbols.add("c"); + symbols.add("d"); + symbols.add("r"); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(TrieTest.class); + } +}