source: trunk/quest-core-event-test/src/de/ugoe/cs/quest/data/ReplayableEventTest.java @ 432

Last change on this file since 432 was 432, checked in by sherbold, 12 years ago
  • renamed packages to fir QUEST project structure
  • Property svn:mime-type set to text/plain
File size: 16.9 KB
Line 
1package de.ugoe.cs.quest.data;
2
3import java.util.LinkedList;
4import java.util.List;
5
6import junitx.framework.ListAssert;
7import de.ugoe.cs.quest.IReplayDecorator;
8import de.ugoe.cs.quest.data.ReplayableEvent;
9import de.ugoe.cs.quest.data.mock.MockReplayable;
10
11import org.junit.*;
12import static org.junit.Assert.*;
13
14/**
15 * The class <code>ReplayableEventTest</code> contains tests for the class
16 * <code>{@link ReplayableEvent}</code>.
17 *
18 * @generatedBy CodePro at 12/20/11 10:17 AM
19 * @author Steffen Herbold
20 * @version 1.0
21 */
22public class ReplayableEventTest {
23
24        private static class StubReplayDecorator implements IReplayDecorator {
25
26                private static final long serialVersionUID = 1L;
27
28                @Override
29                public String getHeader() {
30                        return null;
31                }
32
33                @Override
34                public String getFooter() {
35                        return null;
36                }
37
38                @Override
39                public String getSessionHeader(int sessionId) {
40                        return null;
41                }
42
43                @Override
44                public String getSessionFooter(int sessionId) {
45                        return null;
46                }
47               
48        }
49
50        @Test
51        public void testReplayableEvent_1() throws Exception {
52                String type = "typeString";
53
54                ReplayableEvent<MockReplayable> result = new ReplayableEvent<MockReplayable>(
55                                type);
56
57                assertNotNull(result);
58                assertNotNull(result.replayEvents);
59                assertTrue(result.replayEvents.isEmpty());
60                assertEquals(true, result.replayValid);
61                assertEquals(null, result.decorator);
62        }
63
64        @Test(expected = java.security.InvalidParameterException.class)
65        public void testReplayableEvent_2() throws Exception {
66                new ReplayableEvent<MockReplayable>(null);
67        }
68
69        @Test
70        public void testAddReplayEvent_1() throws Exception {
71                String type = "typeString";
72                String replayableReplay = "replayString";
73                String replaybleTarget = "replayTargetString";
74                MockReplayable replayable = new MockReplayable(replayableReplay,
75                                replaybleTarget);
76                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
77                                type);
78                fixture.addReplayEvent(replayable);
79               
80               
81                assertEquals(1, fixture.replayEvents.size());
82                assertEquals(replayable, fixture.replayEvents.get(0));
83        }
84       
85        @Test
86        public void testAddReplayEvent_2() throws Exception {
87                String type = "typeString";
88                String replayableReplay1 = "replayString1";
89                String replayableReplay2 = "replayString2";
90                String replaybleTarget1 = "replayTargetString1";
91                String replaybleTarget2 = "replayTargetString2";
92                MockReplayable replayable1 = new MockReplayable(replayableReplay1,
93                                replaybleTarget1);
94                MockReplayable replayable2 = new MockReplayable(replayableReplay2, replaybleTarget2);
95                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
96                                type);
97                fixture.addReplayEvent(replayable1);
98                fixture.addReplayEvent(replayable2);
99               
100               
101                assertEquals(2, fixture.replayEvents.size());
102                assertEquals(replayable1, fixture.replayEvents.get(0));
103                assertEquals(replayable2, fixture.replayEvents.get(1));
104        }
105
106        @Test(expected = java.security.InvalidParameterException.class )
107        public void testAddReplayEvent_fixture_3() throws Exception {
108                String type = "typeString";
109                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
110                                type);
111                fixture.addReplayEvent(null);
112        }
113
114        @Test
115        public void testAddReplaySequence_1() throws Exception {
116                String type = "typeString";
117                String replayableReplay1 = "replayString1";
118                String replayableReplay2 = "replayString2";
119                String replaybleTarget1 = "replayTargetString1";
120                String replaybleTarget2 = "replayTargetString2";
121                MockReplayable replayable1 = new MockReplayable(replayableReplay1,
122                                replaybleTarget1);
123                MockReplayable replayable2 = new MockReplayable(replayableReplay2, replaybleTarget2);
124                List<MockReplayable> replaySequence = new LinkedList<MockReplayable>();
125                replaySequence.add(replayable1);
126                replaySequence.add(replayable2);
127                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
128                                type);
129               
130                fixture.addReplaySequence(replaySequence);             
131               
132                assertEquals(2, fixture.replayEvents.size());
133                assertEquals(replayable1, fixture.replayEvents.get(0));
134                assertEquals(replayable2, fixture.replayEvents.get(1));
135        }
136
137        @Test(expected = java.security.InvalidParameterException.class )
138        public void testAddReplaySequence_2() throws Exception {
139                String type = "typeString";
140                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
141                                type);
142               
143                fixture.addReplaySequence(null);       
144        }
145
146        @Test
147        public void testEquals_1() throws Exception {
148                String type = "typeString";
149                boolean replayValid = true;
150                String replayableReplay1 = "replayString1";
151                String replayableReplay2 = "replayString2";
152                String replayableTarget1 = "replayTargetString1";
153                String replayableTarget2 = "replayTargetString2";
154                MockReplayable replayable1 = new MockReplayable(replayableReplay1,
155                                replayableTarget1);
156                MockReplayable replayable2 = new MockReplayable(replayableReplay2, replayableTarget2);
157                List<MockReplayable> replaySequence = new LinkedList<MockReplayable>();
158                replaySequence.add(replayable1);
159                replaySequence.add(replayable2);
160                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
161                                type);
162                fixture.replayEvents = replaySequence;
163                fixture.replayValid = replayValid;
164               
165                String typeOther = "typeString";
166                boolean replayValidOther = true;
167                String replayableReplayOther1 = "replayString1";
168                String replayableReplayOther2 = "replayString2";
169                String replaybleTargetOther1 = "replayTargetString1";
170                String replaybleTargetOther2 = "replayTargetString2";
171                MockReplayable replayableOther1 = new MockReplayable(replayableReplayOther1,
172                                replaybleTargetOther1);
173                MockReplayable replayableOther2 = new MockReplayable(replayableReplayOther2, replaybleTargetOther2);
174                List<MockReplayable> replaySequenceOther = new LinkedList<MockReplayable>();
175                replaySequenceOther.add(replayableOther1);
176                replaySequenceOther.add(replayableOther2);
177                ReplayableEvent<MockReplayable> other = new ReplayableEvent<MockReplayable>(
178                                typeOther);
179                other.replayEvents = replaySequenceOther;
180                other.replayValid = replayValidOther;
181
182                boolean result = fixture.equals(other);
183
184                assertEquals(true, result);
185        }
186       
187        @Test
188        public void testEquals_2() throws Exception {
189                String type = "typeString";
190                boolean replayValid = true;
191                String replayableReplay1 = "replayString1";
192                String replayableReplay2 = "replayString2";
193                String replayableTarget1 = "replayTargetString1";
194                String replayableTarget2 = "replayTargetString2";
195                MockReplayable replayable1 = new MockReplayable(replayableReplay1,
196                                replayableTarget1);
197                MockReplayable replayable2 = new MockReplayable(replayableReplay2, replayableTarget2);
198                List<MockReplayable> replaySequence = new LinkedList<MockReplayable>();
199                replaySequence.add(replayable1);
200                replaySequence.add(replayable2);
201                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
202                                type);
203                fixture.replayEvents = replaySequence;
204                fixture.replayValid = replayValid;
205               
206                String typeOther = "typeString2";
207                boolean replayValidOther = true;
208                String replayableReplayOther1 = "replayString1";
209                String replayableReplayOther2 = "replayString2";
210                String replaybleTargetOther1 = "replayTargetString1";
211                String replaybleTargetOther2 = "replayTargetString2";
212                MockReplayable replayableOther1 = new MockReplayable(replayableReplayOther1,
213                                replaybleTargetOther1);
214                MockReplayable replayableOther2 = new MockReplayable(replayableReplayOther2, replaybleTargetOther2);
215                List<MockReplayable> replaySequenceOther = new LinkedList<MockReplayable>();
216                replaySequenceOther.add(replayableOther1);
217                replaySequenceOther.add(replayableOther2);
218                ReplayableEvent<MockReplayable> other = new ReplayableEvent<MockReplayable>(
219                                typeOther);
220                other.replayEvents = replaySequenceOther;
221                other.replayValid = replayValidOther;
222
223                boolean result = fixture.equals(other);
224
225                assertEquals(false, result);
226        }
227       
228        @Test
229        public void testEquals_3() throws Exception {
230                String type = "typeString";
231                boolean replayValid = true;
232                String replayableReplay1 = "replayString1";
233                String replayableReplay2 = "replayString2";
234                String replayableTarget1 = "replayTargetString1";
235                String replayableTarget2 = "replayTargetString2";
236                MockReplayable replayable1 = new MockReplayable(replayableReplay1,
237                                replayableTarget1);
238                MockReplayable replayable2 = new MockReplayable(replayableReplay2, replayableTarget2);
239                List<MockReplayable> replaySequence = new LinkedList<MockReplayable>();
240                replaySequence.add(replayable1);
241                replaySequence.add(replayable2);
242                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
243                                type);
244                fixture.replayEvents = replaySequence;
245                fixture.replayValid = replayValid;
246               
247                String typeOther = "typeString";
248                boolean replayValidOther = true;
249                String replayableReplayOther1 = "replayString3";
250                String replayableReplayOther2 = "replayString2";
251                String replaybleTargetOther1 = "replayTargetString1";
252                String replaybleTargetOther2 = "replayTargetString2";
253                MockReplayable replayableOther1 = new MockReplayable(replayableReplayOther1,
254                                replaybleTargetOther1);
255                MockReplayable replayableOther2 = new MockReplayable(replayableReplayOther2, replaybleTargetOther2);
256                List<MockReplayable> replaySequenceOther = new LinkedList<MockReplayable>();
257                replaySequenceOther.add(replayableOther1);
258                replaySequenceOther.add(replayableOther2);
259                ReplayableEvent<MockReplayable> other = new ReplayableEvent<MockReplayable>(
260                                typeOther);
261                other.replayEvents = replaySequenceOther;
262                other.replayValid = replayValidOther;
263
264                boolean result = fixture.equals(other);
265
266                assertEquals(true, result);
267        }
268       
269        @Test
270        public void testEquals_4() throws Exception {
271                String type = "typeString";
272                boolean replayValid = true;
273                String replayableReplay1 = "replayString1";
274                String replayableReplay2 = "replayString2";
275                String replayableTarget1 = "replayTargetString1";
276                String replayableTarget2 = "replayTargetString2";
277                MockReplayable replayable1 = new MockReplayable(replayableReplay1,
278                                replayableTarget1);
279                MockReplayable replayable2 = new MockReplayable(replayableReplay2, replayableTarget2);
280                List<MockReplayable> replaySequence = new LinkedList<MockReplayable>();
281                replaySequence.add(replayable1);
282                replaySequence.add(replayable2);
283                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
284                                type);
285                fixture.replayEvents = replaySequence;
286                fixture.replayValid = replayValid;
287               
288                String typeOther = "typeString";
289                boolean replayValidOther = true;
290                String replayableReplayOther1 = "replayString1";
291                String replayableReplayOther2 = "replayString3";
292                String replaybleTargetOther1 = "replayTargetString1";
293                String replaybleTargetOther2 = "replayTargetString2";
294                MockReplayable replayableOther1 = new MockReplayable(replayableReplayOther1,
295                                replaybleTargetOther1);
296                MockReplayable replayableOther2 = new MockReplayable(replayableReplayOther2, replaybleTargetOther2);
297                List<MockReplayable> replaySequenceOther = new LinkedList<MockReplayable>();
298                replaySequenceOther.add(replayableOther1);
299                replaySequenceOther.add(replayableOther2);
300                ReplayableEvent<MockReplayable> other = new ReplayableEvent<MockReplayable>(
301                                typeOther);
302                other.replayEvents = replaySequenceOther;
303                other.replayValid = replayValidOther;
304
305                boolean result = fixture.equals(other);
306
307                assertEquals(true, result);
308        }
309       
310        @Test
311        public void testEquals_5() throws Exception {
312                String type = "typeString";
313                boolean replayValid = true;
314                String replayableReplay1 = "replayString1";
315                String replayableReplay2 = "replayString2";
316                String replayableTarget1 = "replayTargetString1";
317                String replayableTarget2 = "replayTargetString2";
318                MockReplayable replayable1 = new MockReplayable(replayableReplay1,
319                                replayableTarget1);
320                MockReplayable replayable2 = new MockReplayable(replayableReplay2, replayableTarget2);
321                List<MockReplayable> replaySequence = new LinkedList<MockReplayable>();
322                replaySequence.add(replayable1);
323                replaySequence.add(replayable2);
324                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
325                                type);
326                fixture.replayEvents = replaySequence;
327                fixture.replayValid = replayValid;
328               
329                String typeOther = "typeString";
330                boolean replayValidOther = false;
331                String replayableReplayOther1 = "replayString1";
332                String replayableReplayOther2 = "replayString2";
333                String replaybleTargetOther1 = "replayTargetString1";
334                String replaybleTargetOther2 = "replayTargetString2";
335                MockReplayable replayableOther1 = new MockReplayable(replayableReplayOther1,
336                                replaybleTargetOther1);
337                MockReplayable replayableOther2 = new MockReplayable(replayableReplayOther2, replaybleTargetOther2);
338                List<MockReplayable> replaySequenceOther = new LinkedList<MockReplayable>();
339                replaySequenceOther.add(replayableOther1);
340                replaySequenceOther.add(replayableOther2);
341                ReplayableEvent<MockReplayable> other = new ReplayableEvent<MockReplayable>(
342                                typeOther);
343                other.replayEvents = replaySequenceOther;
344                other.replayValid = replayValidOther;
345
346                boolean result = fixture.equals(other);
347
348                assertEquals(true, result);
349        }
350       
351        @Test
352        public void testEquals_6() throws Exception {
353                String type = "typeString";
354                boolean replayValid = true;
355                String replayableReplay1 = "replayString1";
356                String replayableReplay2 = "replayString2";
357                String replayableTarget1 = "replayTargetString1";
358                String replayableTarget2 = "replayTargetString2";
359                MockReplayable replayable1 = new MockReplayable(replayableReplay1,
360                                replayableTarget1);
361                MockReplayable replayable2 = new MockReplayable(replayableReplay2, replayableTarget2);
362                List<MockReplayable> replaySequence = new LinkedList<MockReplayable>();
363                replaySequence.add(replayable1);
364                replaySequence.add(replayable2);
365                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
366                                type);
367                fixture.replayEvents = replaySequence;
368                fixture.replayValid = replayValid;
369
370                boolean result = fixture.equals(fixture);
371
372                assertEquals(true, result);
373        }
374
375        @Test
376        public void testGetReplayDecorator_1() throws Exception {
377                String type = "typeString";
378                StubReplayDecorator decorator = new StubReplayDecorator();
379                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
380                                type);
381                fixture.decorator = decorator;
382
383                IReplayDecorator result = fixture.getReplayDecorator();
384
385                assertEquals(decorator, result);
386        }
387
388        @Test
389        public void testGetReplayMessages_1() throws Exception {
390                String type = "typeString";
391                String replayableReplay1 = "replayString1";
392                String replayableReplay2 = "replayString2";
393                String replayableTarget1 = "replayTargetString1";
394                String replayableTarget2 = "replayTargetString2";
395                MockReplayable replayable1 = new MockReplayable(replayableReplay1,
396                                replayableTarget1);
397                MockReplayable replayable2 = new MockReplayable(replayableReplay2, replayableTarget2);
398                List<MockReplayable> replaySequence = new LinkedList<MockReplayable>();
399                replaySequence.add(replayable1);
400                replaySequence.add(replayable2);
401                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
402                                type);
403                fixture.replayEvents = replaySequence;
404
405                List<MockReplayable> result = fixture.getReplayMessages();
406
407                ListAssert.assertEquals(replaySequence, result);
408        }
409
410        @Test
411        public void testHasValidReplay_1() throws Exception {
412                String type = "typeString";
413                boolean replayValid = true;
414                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
415                                type);
416                fixture.replayValid = replayValid;
417
418                boolean result = fixture.hasValidReplay();
419
420                assertEquals(replayValid, result);
421        }
422       
423        @Test
424        public void testHasValidReplay_2() throws Exception {
425                String type = "typeString";
426                boolean replayValid = false;
427                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
428                                type);
429                fixture.replayValid = replayValid;
430
431                boolean result = fixture.hasValidReplay();
432
433                assertEquals(replayValid, result);
434        }
435
436        @Test
437        public void testInvalidateReplay_1() throws Exception {
438                String type = "typeString";
439                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
440                                type);
441               
442                fixture.invalidateReplay();
443
444                assertFalse(fixture.replayValid);
445        }
446       
447        @Test
448        public void testInvalidateReplay_2() throws Exception {
449                String type = "typeString";
450                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
451                                type);
452               
453                fixture.invalidateReplay();
454                fixture.invalidateReplay();
455
456                assertFalse(fixture.replayValid);
457        }
458
459        @Test
460        public void testSetDecorator_fixture_1() throws Exception {
461                String type = "typeString";
462                StubReplayDecorator decorator = new StubReplayDecorator();
463                ReplayableEvent<MockReplayable> fixture = new ReplayableEvent<MockReplayable>(
464                                type);
465
466                fixture.setDecorator(decorator);
467
468                assertEquals(decorator, fixture.decorator);
469        }
470
471        public static void main(String[] args) {
472                new org.junit.runner.JUnitCore().run(ReplayableEventTest.class);
473        }
474}
Note: See TracBrowser for help on using the repository browser.