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

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