source: trunk/quest-core-coverage-test/src/test/java/de/ugoe/cs/quest/coverage/CoverageCalculatorObservedTest.java @ 553

Last change on this file since 553 was 553, checked in by sherbold, 12 years ago
  • countless adaptations throughout nearly all components to remove errors introduced due to the refactoring of the event core
  • added StringEventType? as a simple-to-use event type instead of DummyEventType?
  • Property svn:mime-type set to text/plain
File size: 9.6 KB
Line 
1package de.ugoe.cs.quest.coverage;
2
3import java.util.ArrayList;
4import java.util.Collection;
5import de.ugoe.cs.quest.coverage.CoverageCalculatorObserved;
6import de.ugoe.cs.quest.eventcore.Event;
7import de.ugoe.cs.quest.eventcore.StringEventType;
8import de.ugoe.cs.quest.usageprofiles.MockTrieBasedModel;
9
10import java.util.LinkedHashSet;
11import java.util.LinkedList;
12import java.util.List;
13import java.util.Random;
14import java.util.Set;
15
16import org.junit.*;
17
18import static org.junit.Assert.*;
19
20/**
21 * The class <code>CoverageCalculatorObservedTest</code> contains tests for the
22 * class <code>{@link CoverageCalculatorObserved}</code>.
23 *
24 * @author Steffen Herbold
25 * @version 1.0
26 */
27public class CoverageCalculatorObservedTest {
28       
29        Collection<List<Event>> sequencesObserved;
30       
31        Set<List<Event>> sequencesCovered;
32        Set<List<Event>> sequencesCovered2;
33        Set<List<Event>> sequencesNewPossible;
34       
35        MockTrieBasedModel mockProcess;
36       
37        @Test
38        public void testCoverageCalculatorObserved_1() throws Exception {
39                int length = 2;
40
41                CoverageCalculatorObserved result = new CoverageCalculatorObserved(
42                                sequencesObserved, sequencesCovered, length);
43                assertNotNull(result);
44        }
45
46        @Test(expected = java.security.InvalidParameterException.class)
47        public void testCoverageCalculatorObserved_2() throws Exception {
48                int length = 2;
49
50                new CoverageCalculatorObserved(null,sequencesCovered, length);
51        }
52
53        @Test(expected = java.security.InvalidParameterException.class)
54        public void testCoverageCalculatorObserved_3() throws Exception {
55                int length = 2;
56
57                new CoverageCalculatorObserved(sequencesObserved, null, length);
58        }
59
60        @Test(expected = java.security.InvalidParameterException.class)
61        public void testCoverageCalculatorObserved_4() throws Exception {
62                int length = 0;
63
64                new CoverageCalculatorObserved(sequencesObserved, sequencesCovered, length);
65        }
66
67        @Test(expected = java.security.InvalidParameterException.class)
68        public void testCoverageCalculatorObserved_5() throws Exception {
69                int length = -1;
70
71                new CoverageCalculatorObserved(sequencesObserved, sequencesCovered, length);
72        }
73       
74        @Test
75        public void testCoverageObserved_1() throws Exception {
76                int length = 2;
77                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
78                                sequencesObserved, sequencesCovered, length);
79               
80                double result = fixture.getCoverageObserved();
81               
82                assertEquals(3.0/6.0, result, 0.0001);
83        }
84       
85        @Test
86        public void testCoverageObserved_2() throws Exception {
87                int length = 2;
88                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
89                                sequencesObserved, sequencesCovered2, length);
90               
91                double result = fixture.getCoverageObserved();
92               
93                assertEquals(2.0/6.0, result, 0.0001);
94        }
95       
96        @Test
97        public void testCoverageObservedWeigth_1() throws Exception {
98                int length = 2;
99                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
100                                sequencesObserved, sequencesCovered, length);
101               
102                double result = fixture.getCoverageObservedWeigth(mockProcess);
103               
104                assertEquals(6.0, result, 0.0001);
105        }
106       
107        @Test
108        public void testCoverageObservedWeigth_2() throws Exception {
109                int length = 2;
110                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
111                                sequencesObserved, sequencesCovered2, length);
112               
113                double result = fixture.getCoverageObservedWeigth(mockProcess);
114               
115                assertEquals(4.0, result, 0.0001);
116        }
117       
118        @Test
119        public void testGetNewPercentage_1() throws Exception {
120                int length = 2;
121                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
122                                sequencesObserved, sequencesCovered, length);
123               
124                double result = fixture.getNewPercentage();
125               
126                assertEquals(1.0/4.0, result, 0.0001);
127        }
128       
129        @Test
130        public void testGetNewPercentage_2() throws Exception {
131                int length = 2;
132                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
133                                sequencesObserved, sequencesCovered2, length);
134               
135                double result = fixture.getNewPercentage();
136               
137                assertEquals(0.0, result, 0.0001);
138        }
139       
140        @Test
141        public void testCoveragePossibleNew_1() throws Exception {
142                int length = 3;
143                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
144                                sequencesObserved, sequencesNewPossible, length);
145               
146                double result = fixture.getCoveragePossibleNew(mockProcess);
147               
148                assertEquals(1.0/11.0, result, 0.0001);
149        }
150       
151        @Test
152        public void testCoveragePossibleNew_2() throws Exception {
153                int length = 2;
154                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
155                                sequencesObserved, sequencesCovered, length);
156               
157                double result = fixture.getCoveragePossibleNew(mockProcess);
158               
159                assertEquals(0.0, result, 0.0001);
160        }
161       
162        @Test(expected = java.security.InvalidParameterException.class )
163        public void testCoveragePossibleNew_3() throws Exception {
164                int length = 3;
165                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
166                                sequencesObserved, sequencesCovered, length);
167               
168                fixture.getCoveragePossibleNew(null);
169        }
170       
171        @Test
172        public void testCoveragePossibleNewWeight_1() throws Exception {
173                int length = 3;
174                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
175                                sequencesObserved, sequencesNewPossible, length);
176               
177                double result = fixture.getCoveragePossibleNewWeight(mockProcess);
178               
179                assertEquals(2.0, result, 0.0001);
180        }
181       
182        @Test
183        public void testCoveragePossibleNewWeight_2() throws Exception {
184                int length = 2;
185                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
186                                sequencesObserved, sequencesCovered, length);
187               
188                double result = fixture.getCoveragePossibleNewWeight(mockProcess);
189               
190                assertEquals(0.0, result, 0.0001);
191        }
192       
193        @Test(expected = java.security.InvalidParameterException.class )
194        public void testCoveragePossibleNewWeight_3() throws Exception {
195                int length = 3;
196                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
197                                sequencesObserved, sequencesCovered, length);
198               
199                fixture.getCoveragePossibleNewWeight(null);
200        }       
201       
202       
203        @Test
204        public void testGetNumObserved_1() throws Exception {
205                int length = 2;
206                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
207                                sequencesObserved, sequencesCovered, length);
208               
209                int result = fixture.getNumObserved();
210               
211                assertEquals(6, result);
212        }
213       
214        @Test
215        public void testGetNumCovered_1() throws Exception {
216                int length = 2;
217                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
218                                sequencesObserved, sequencesCovered, length);
219               
220                int result = fixture.getNumCovered();
221               
222                assertEquals(4, result);
223        }
224       
225        @Test
226        public void testGetNumCovered_2() throws Exception {
227                int length = 2;
228                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
229                                sequencesObserved, sequencesCovered2, length);
230               
231                int result = fixture.getNumCovered();
232               
233                assertEquals(2, result);
234        }
235       
236        @Test
237        public void testGetNumNew_1() throws Exception {
238                int length = 2;
239                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
240                                sequencesObserved, sequencesCovered, length);
241               
242                int result = fixture.getNumNew();
243               
244                assertEquals(1, result);
245        }
246       
247        @Test
248        public void testGetNumNew_2() throws Exception {
249                int length = 2;
250                CoverageCalculatorObserved fixture = new CoverageCalculatorObserved(
251                                sequencesObserved, sequencesCovered2, length);
252               
253                int result = fixture.getNumNew();
254               
255                assertEquals(0, result);
256        }
257       
258        @Before
259        public void setUp() throws Exception {
260                sequencesObserved = new LinkedList<List<Event>>();
261                List<Event> sequence1 = new ArrayList<Event>();
262                sequence1.add(new Event(new StringEventType("a")));
263                sequence1.add(new Event(new StringEventType("b")));
264                sequence1.add(new Event(new StringEventType("r")));
265                sequence1.add(new Event(new StringEventType("a")));
266                List<Event> sequence2 = new ArrayList<Event>();
267                sequence2.add(new Event(new StringEventType("c")));
268                sequence2.add(new Event(new StringEventType("a")));
269                sequence2.add(new Event(new StringEventType("d")));
270                sequence2.add(new Event(new StringEventType("a")));
271                sequence2.add(new Event(new StringEventType("b")));
272                sequence2.add(new Event(new StringEventType("r")));
273                sequence2.add(new Event(new StringEventType("a")));
274                sequencesObserved.add(sequence1);
275                sequencesObserved.add(sequence2);
276
277                sequencesCovered = new LinkedHashSet<List<Event>>();
278                List<Event> tmpList = new ArrayList<Event>();
279                tmpList.add(new Event(new StringEventType("a")));
280                tmpList.add(new Event(new StringEventType("b")));
281                tmpList.add(new Event(new StringEventType("r")));
282                sequencesCovered.add(tmpList);
283                tmpList = new ArrayList<Event>();
284                tmpList.add(new Event(new StringEventType("b")));
285                tmpList.add(new Event(new StringEventType("r")));
286                tmpList.add(new Event(new StringEventType("a")));
287                tmpList.add(new Event(new StringEventType("e")));
288                sequencesCovered.add(tmpList);
289
290                sequencesCovered2 = new LinkedHashSet<List<Event>>();
291                tmpList = new ArrayList<Event>();
292                tmpList.add(new Event(new StringEventType("a")));
293                tmpList.add(new Event(new StringEventType("b")));
294                tmpList.add(new Event(new StringEventType("r")));
295                sequencesCovered2.add(tmpList);
296               
297                sequencesNewPossible = new LinkedHashSet<List<Event>>();
298                tmpList = new ArrayList<Event>();
299                tmpList.add(new Event(new StringEventType("r")));
300                tmpList.add(new Event(new StringEventType("a")));
301                tmpList.add(new Event(new StringEventType("b")));
302                sequencesNewPossible.add(tmpList);
303               
304                int markovOrder = 2;
305                mockProcess = new MockTrieBasedModel(markovOrder, new Random());
306                mockProcess.train(sequencesObserved);
307        }
308
309        public static void main(String[] args) {
310                new org.junit.runner.JUnitCore()
311                                .run(CoverageCalculatorObservedTest.class);
312        }
313
314}
Note: See TracBrowser for help on using the repository browser.