source: trunk/EventBenchCoreTest/src/de/ugoe/cs/eventbench/coverage/CoverageCalculatorObservedTest.java @ 332

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