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

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