Index: /trunk/EventBenchCoreTest/.classpath =================================================================== --- /trunk/EventBenchCoreTest/.classpath (revision 337) +++ /trunk/EventBenchCoreTest/.classpath (revision 338) @@ -24,8 +24,11 @@ - + - + + + + Index: /trunk/EventBenchCoreTest/src/de/ugoe/cs/eventbench/TestAll.java =================================================================== --- /trunk/EventBenchCoreTest/src/de/ugoe/cs/eventbench/TestAll.java (revision 337) +++ /trunk/EventBenchCoreTest/src/de/ugoe/cs/eventbench/TestAll.java (revision 338) @@ -18,15 +18,9 @@ SequenceInstanceOfTest.class, de.ugoe.cs.eventbench.coverage.TestAll.class, + de.ugoe.cs.eventbench.data.TestAll.class, de.ugoe.cs.eventbench.models.TestAll.class }) public class TestAll { - /** - * Launch the test. - * - * @param args the command line arguments - * - * @generatedBy CodePro at 12/15/11 3:35 PM - */ public static void main(String[] args) { JUnitCore.runClasses(new Class[] { TestAll.class }); Index: /trunk/EventBenchCoreTest/src/de/ugoe/cs/eventbench/data/EventTest.java =================================================================== --- /trunk/EventBenchCoreTest/src/de/ugoe/cs/eventbench/data/EventTest.java (revision 338) +++ /trunk/EventBenchCoreTest/src/de/ugoe/cs/eventbench/data/EventTest.java (revision 338) @@ -0,0 +1,403 @@ +package de.ugoe.cs.eventbench.data; + +import nl.jqno.equalsverifier.EqualsVerifier; +import nl.jqno.equalsverifier.Warning; + +import org.junit.*; + +import static org.junit.Assert.*; + +/** + * The class EventTest contains tests for the class + * {@link Event}. + * + * @author Steffen Herbold + * @version 1.0 + */ +public class EventTest { + + @Test + public void testEvent_1() throws Exception { + String type = "typeString"; + + Event result = new Event(type); + + assertNotNull(result); + assertEquals(type, result.type); + assertNull(result.target); + assertNull(result.targetShort); + assertEquals("", result.idInfo); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testEvent_2() throws Exception { + new Event(null); + } + + @Test + public void testEquals_1() throws Exception { + String type1 = "typeString"; + String type2 = "typeString"; + Event fixture = new Event(type1); + Event other = new Event(type2); + + boolean result = fixture.equals(other); + + assertTrue(result); + } + + @Test + public void testEquals_2() throws Exception { + String type1 = "typeString1"; + String type2 = "typeString2"; + Event fixture = new Event(type1); + Event other = new Event(type2); + + boolean result = fixture.equals(other); + + assertFalse(result); + } + + @Test + public void testEquals_3() throws Exception { + String type1 = "typeString"; + String type2 = "typeString"; + String target1 = "target"; + String target2 = "target"; + Event fixture = new Event(type1); + fixture.target = target1; + Event other = new Event(type2); + other.target = target2; + + boolean result = fixture.equals(other); + + assertTrue(result); + } + + @Test + public void testEquals_4() throws Exception { + String type1 = "typeString1"; + String type2 = "typeString2"; + String target1 = "target"; + String target2 = "target"; + Event fixture = new Event(type1); + fixture.target = target1; + Event other = new Event(type2); + other.target = target2; + + boolean result = fixture.equals(other); + + assertFalse(result); + } + + @Test + public void testEquals_5() throws Exception { + String type1 = "typeString"; + String type2 = "typeString"; + String target1 = "target1"; + String target2 = "target2"; + Event fixture = new Event(type1); + fixture.target = target1; + Event other = new Event(type2); + other.target = target2; + + boolean result = fixture.equals(other); + + assertFalse(result); + } + + @Test + public void testEquals_6() throws Exception { + String type = "typeString"; + Event fixture = new Event(type); + + boolean result = fixture.equals(fixture); + + assertTrue(result); + } + + @Test + public void testEqualsContract() throws Exception { + EqualsVerifier.forClass(Event.class) + .suppress(Warning.NONFINAL_FIELDS).withRedefinedSubclass(ReplayableEvent.class) + .verify(); + } + + @Test + public void testGetIdInfo_fixture_1() throws Exception { + String type = "typeString"; + String idInfo = "idInfoString"; + Event fixture = new Event(type); + fixture.idInfo = idInfo; + + String result = fixture.getIdInfo(); + + assertEquals(idInfo, result); + } + + @Test + public void testGetShortId_1() throws Exception { + String type = "typeString"; + String targetShort = "targetShortString"; + Event fixture = new Event(type); + fixture.targetShort = targetShort; + + String result = fixture.getShortId(); + + assertEquals("targetShortString.typeString", result); + } + + @Test + public void testGetShortId_2() throws Exception { + String type = "typeString"; + String targetShort = "targetShortString"; + String idInfo = "idInfoString"; + Event fixture = new Event(type); + fixture.targetShort = targetShort; + fixture.idInfo = idInfo; + + String result = fixture.getShortId(); + + assertEquals("targetShortString.typeString.idInfoString", result); + } + + @Test + public void testGetShortId_3() throws Exception { + String type = "typeString"; + String target = "targetString"; + Event fixture = new Event(type); + fixture.target = target; + + String result = fixture.getShortId(); + + assertEquals("targetString.typeString", result); + } + + @Test + public void testGetStandardId_1() throws Exception { + String type = "typeString"; + String target = "targetString"; + Event fixture = new Event(type); + fixture.target = target; + + String result = fixture.getStandardId(); + + assertEquals("targetString.typeString", result); + } + + @Test + public void testGetStandardId_2() throws Exception { + String type = "typeString"; + String target = "targetString"; + String idInfo = "idInfoString"; + Event fixture = new Event(type); + fixture.target = target; + fixture.idInfo = idInfo; + + String result = fixture.getStandardId(); + + assertEquals("targetString.typeString.idInfoString", result); + } + + @Test + public void testGetStandardId_3() throws Exception { + String type = "typeString"; + Event fixture = new Event(type); + + String result = fixture.getStandardId(); + + assertEquals("typeString", result); + } + + @Test + public void testGetStandardId_4() throws Exception { + String type = "typeString"; + String idInfo = "idInfoString"; + Event fixture = new Event(type); + fixture.idInfo = idInfo; + + String result = fixture.getStandardId(); + + assertEquals("typeString.idInfoString", result); + } + + @Test + public void testGetTarget_1() throws Exception { + String type = "typeString"; + String target = "targetString"; + Event fixture = new Event(type); + fixture.target = target; + + String result = fixture.getTarget(); + + assertEquals(target, result); + } + + @Test + public void testGetTarget_2() throws Exception { + String type = "typeString"; + Event fixture = new Event(type); + + String result = fixture.getTarget(); + + assertNull(result); + } + + @Test + public void testGetTargetShort_1() throws Exception { + String type = "typeString"; + String targetShort = "targetShort"; + Event fixture = new Event(type); + fixture.targetShort = targetShort; + + String result = fixture.getTargetShort(); + + assertEquals(targetShort, result); + } + + @Test + public void testGetTargetShort_2() throws Exception { + String type = "typeString"; + Event fixture = new Event(type); + + String result = fixture.getTargetShort(); + + assertNull(result); + } + + @Test + public void testGetType_1() throws Exception { + String type = "typeString"; + Event fixture = new Event(type); + + String result = fixture.getType(); + + assertEquals(type, result); + } + + @Test + public void testSetIdInfo_fixture_1() throws Exception { + String type = "typeString"; + String idInfo = "idInfoString"; + Event fixture = new Event(type); + + fixture.setIdInfo(idInfo); + + assertEquals(idInfo, fixture.idInfo); + } + + @Test + public void testSetIdInfo_2() throws Exception { + String type = "typeString"; + String idInfo = null; + Event fixture = new Event(type); + + fixture.setIdInfo(idInfo); + + assertEquals(idInfo, fixture.idInfo); + } + + @Test + public void testSetTarget_1() throws Exception { + String type = "typeString"; + String target = "targetString"; + Event fixture = new Event(type); + + boolean result = fixture.setTarget(target); + + assertTrue(result); + assertEquals(target, fixture.target); + } + + @Test + public void testSetTarget_2() throws Exception { + String type = "typeString"; + String target1 = "targetString1"; + String target2 = "targetString2"; + Event fixture = new Event(type); + fixture.target = target1; + + boolean result = fixture.setTarget(target2); + + assertFalse(result); + assertEquals(target1, fixture.target); + } + + @Test + public void testSetTargetShort_1() throws Exception { + String type = "typeString"; + String targetShort = "targetShortString"; + Event fixture = new Event(type); + + boolean result = fixture.setTargetShort(targetShort); + + assertTrue(result); + assertEquals(targetShort, fixture.targetShort); + } + + @Test + public void testSetTargetShort_2() throws Exception { + String type = "typeString"; + String targetShort1 = "targetShortString1"; + String targetShort2 = "targetShortString2"; + Event fixture = new Event(type); + fixture.targetShort = targetShort1; + + boolean result = fixture.setTargetShort(targetShort2); + + assertFalse(result); + assertEquals(targetShort1, fixture.targetShort); + } + + @Test + public void testToString_1() throws Exception { + String type = "typeString"; + String target = "targetString"; + Event fixture = new Event(type); + fixture.target = target; + + String result = fixture.toString(); + + assertEquals("targetString.typeString", result); + } + + @Test + public void testToString_2() throws Exception { + String type = "typeString"; + String target = "targetString"; + String idInfo = "idInfoString"; + Event fixture = new Event(type); + fixture.target = target; + fixture.idInfo = idInfo; + + String result = fixture.toString(); + + assertEquals("targetString.typeString.idInfoString", result); + } + + @Test + public void testToString_3() throws Exception { + String type = "typeString"; + Event fixture = new Event(type); + + String result = fixture.toString(); + + assertEquals("typeString", result); + } + + @Test + public void testToString_4() throws Exception { + String type = "typeString"; + String idInfo = "idInfoString"; + Event fixture = new Event(type); + fixture.idInfo = idInfo; + + String result = fixture.toString(); + + assertEquals("typeString.idInfoString", result); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(EventTest.class); + } +} Index: /trunk/EventBenchCoreTest/src/de/ugoe/cs/eventbench/data/ReplayableEventTest.java =================================================================== --- /trunk/EventBenchCoreTest/src/de/ugoe/cs/eventbench/data/ReplayableEventTest.java (revision 338) +++ /trunk/EventBenchCoreTest/src/de/ugoe/cs/eventbench/data/ReplayableEventTest.java (revision 338) @@ -0,0 +1,539 @@ +package de.ugoe.cs.eventbench.data; + +import java.util.LinkedList; +import java.util.List; + +import junitx.framework.ListAssert; +import de.ugoe.cs.eventbench.IReplayDecorator; +import nl.jqno.equalsverifier.EqualsVerifier; +import nl.jqno.equalsverifier.Warning; + +import org.junit.*; +import static org.junit.Assert.*; + +/** + * The class ReplayableEventTest contains tests for the class + * {@link ReplayableEvent}. + * + * @generatedBy CodePro at 12/20/11 10:17 AM + * @author Steffen Herbold + * @version 1.0 + */ +public class ReplayableEventTest { + + private static class MockReplayable implements IReplayable { + + private static final long serialVersionUID = 1L; + + final String replay; + final String target; + + public MockReplayable(String replay, String target) { + this.replay = replay; + this.target = target; + } + + @Override + public String getReplay() { + return replay; + } + + @Override + public String getTarget() { + return target; + } + + @Override + public boolean equals(Object other) { + if (this == other) { + return true; + } + if (other instanceof MockReplayable) { + if (replay != null && target != null) { + return replay.equals(((MockReplayable) other).replay) + && target.equals(((MockReplayable) other).target); + } else if (replay != null && target == null) { + return replay.equals(((MockReplayable) other).replay) + && ((MockReplayable) other).target == null; + } else if (replay == null && target != null) { + return ((MockReplayable) other).replay == null + && target.equals(((MockReplayable) other).target); + } else { + return ((MockReplayable) other).replay == null + && ((MockReplayable) other).target == null; + } + } + return false; + } + + @Override + public int hashCode() { + int hashCode = 17; + if( replay!=null ) { + hashCode *= replay.hashCode(); + } + if( target!=null ) { + hashCode *= target.hashCode(); + } + return hashCode; + } + } + + private static class StubReplayDecorator implements IReplayDecorator { + + private static final long serialVersionUID = 1L; + + @Override + public String getHeader() { + return null; + } + + @Override + public String getFooter() { + return null; + } + + @Override + public String getSessionHeader(int sessionId) { + return null; + } + + @Override + public String getSessionFooter(int sessionId) { + return null; + } + + } + + @Test + public void testReplayableEvent_1() throws Exception { + String type = "typeString"; + + ReplayableEvent result = new ReplayableEvent( + type); + + assertNotNull(result); + assertNotNull(result.replayEvents); + assertTrue(result.replayEvents.isEmpty()); + assertEquals(true, result.replayValid); + assertEquals(null, result.decorator); + } + + @Test(expected = java.security.InvalidParameterException.class) + public void testReplayableEvent_2() throws Exception { + new ReplayableEvent(null); + } + + @Test + public void testAddReplayEvent_1() throws Exception { + String type = "typeString"; + String replayableReplay = "replayString"; + String replaybleTarget = "replayTargetString"; + MockReplayable replayable = new MockReplayable(replayableReplay, + replaybleTarget); + ReplayableEvent fixture = new ReplayableEvent( + type); + fixture.addReplayEvent(replayable); + + + assertEquals(1, fixture.replayEvents.size()); + assertEquals(replayable, fixture.replayEvents.get(0)); + } + + @Test + public void testAddReplayEvent_2() throws Exception { + String type = "typeString"; + String replayableReplay1 = "replayString1"; + String replayableReplay2 = "replayString2"; + String replaybleTarget1 = "replayTargetString1"; + String replaybleTarget2 = "replayTargetString2"; + MockReplayable replayable1 = new MockReplayable(replayableReplay1, + replaybleTarget1); + MockReplayable replayable2 = new MockReplayable(replayableReplay2, replaybleTarget2); + ReplayableEvent fixture = new ReplayableEvent( + type); + fixture.addReplayEvent(replayable1); + fixture.addReplayEvent(replayable2); + + + assertEquals(2, fixture.replayEvents.size()); + assertEquals(replayable1, fixture.replayEvents.get(0)); + assertEquals(replayable2, fixture.replayEvents.get(1)); + } + + @Test(expected = java.security.InvalidParameterException.class ) + public void testAddReplayEvent_fixture_3() throws Exception { + String type = "typeString"; + ReplayableEvent fixture = new ReplayableEvent( + type); + fixture.addReplayEvent(null); + } + + @Test + public void testAddReplaySequence_1() throws Exception { + String type = "typeString"; + String replayableReplay1 = "replayString1"; + String replayableReplay2 = "replayString2"; + String replaybleTarget1 = "replayTargetString1"; + String replaybleTarget2 = "replayTargetString2"; + MockReplayable replayable1 = new MockReplayable(replayableReplay1, + replaybleTarget1); + MockReplayable replayable2 = new MockReplayable(replayableReplay2, replaybleTarget2); + List replaySequence = new LinkedList(); + replaySequence.add(replayable1); + replaySequence.add(replayable2); + ReplayableEvent fixture = new ReplayableEvent( + type); + + fixture.addReplaySequence(replaySequence); + + assertEquals(2, fixture.replayEvents.size()); + assertEquals(replayable1, fixture.replayEvents.get(0)); + assertEquals(replayable2, fixture.replayEvents.get(1)); + } + + @Test(expected = java.security.InvalidParameterException.class ) + public void testAddReplaySequence_2() throws Exception { + String type = "typeString"; + ReplayableEvent fixture = new ReplayableEvent( + type); + + fixture.addReplaySequence(null); + } + + @Test + public void testEquals_1() throws Exception { + String type = "typeString"; + boolean replayValid = true; + String replayableReplay1 = "replayString1"; + String replayableReplay2 = "replayString2"; + String replayableTarget1 = "replayTargetString1"; + String replayableTarget2 = "replayTargetString2"; + MockReplayable replayable1 = new MockReplayable(replayableReplay1, + replayableTarget1); + MockReplayable replayable2 = new MockReplayable(replayableReplay2, replayableTarget2); + List replaySequence = new LinkedList(); + replaySequence.add(replayable1); + replaySequence.add(replayable2); + ReplayableEvent fixture = new ReplayableEvent( + type); + fixture.replayEvents = replaySequence; + fixture.replayValid = replayValid; + + String typeOther = "typeString"; + boolean replayValidOther = true; + String replayableReplayOther1 = "replayString1"; + String replayableReplayOther2 = "replayString2"; + String replaybleTargetOther1 = "replayTargetString1"; + String replaybleTargetOther2 = "replayTargetString2"; + MockReplayable replayableOther1 = new MockReplayable(replayableReplayOther1, + replaybleTargetOther1); + MockReplayable replayableOther2 = new MockReplayable(replayableReplayOther2, replaybleTargetOther2); + List replaySequenceOther = new LinkedList(); + replaySequenceOther.add(replayableOther1); + replaySequenceOther.add(replayableOther2); + ReplayableEvent other = new ReplayableEvent( + typeOther); + other.replayEvents = replaySequenceOther; + other.replayValid = replayValidOther; + + boolean result = fixture.equals(other); + + assertEquals(true, result); + } + + @Test + public void testEquals_2() throws Exception { + String type = "typeString"; + boolean replayValid = true; + String replayableReplay1 = "replayString1"; + String replayableReplay2 = "replayString2"; + String replayableTarget1 = "replayTargetString1"; + String replayableTarget2 = "replayTargetString2"; + MockReplayable replayable1 = new MockReplayable(replayableReplay1, + replayableTarget1); + MockReplayable replayable2 = new MockReplayable(replayableReplay2, replayableTarget2); + List replaySequence = new LinkedList(); + replaySequence.add(replayable1); + replaySequence.add(replayable2); + ReplayableEvent fixture = new ReplayableEvent( + type); + fixture.replayEvents = replaySequence; + fixture.replayValid = replayValid; + + String typeOther = "typeString2"; + boolean replayValidOther = true; + String replayableReplayOther1 = "replayString1"; + String replayableReplayOther2 = "replayString2"; + String replaybleTargetOther1 = "replayTargetString1"; + String replaybleTargetOther2 = "replayTargetString2"; + MockReplayable replayableOther1 = new MockReplayable(replayableReplayOther1, + replaybleTargetOther1); + MockReplayable replayableOther2 = new MockReplayable(replayableReplayOther2, replaybleTargetOther2); + List replaySequenceOther = new LinkedList(); + replaySequenceOther.add(replayableOther1); + replaySequenceOther.add(replayableOther2); + ReplayableEvent other = new ReplayableEvent( + typeOther); + other.replayEvents = replaySequenceOther; + other.replayValid = replayValidOther; + + boolean result = fixture.equals(other); + + assertEquals(false, result); + } + + @Test + public void testEquals_3() throws Exception { + String type = "typeString"; + boolean replayValid = true; + String replayableReplay1 = "replayString1"; + String replayableReplay2 = "replayString2"; + String replayableTarget1 = "replayTargetString1"; + String replayableTarget2 = "replayTargetString2"; + MockReplayable replayable1 = new MockReplayable(replayableReplay1, + replayableTarget1); + MockReplayable replayable2 = new MockReplayable(replayableReplay2, replayableTarget2); + List replaySequence = new LinkedList(); + replaySequence.add(replayable1); + replaySequence.add(replayable2); + ReplayableEvent fixture = new ReplayableEvent( + type); + fixture.replayEvents = replaySequence; + fixture.replayValid = replayValid; + + String typeOther = "typeString"; + boolean replayValidOther = true; + String replayableReplayOther1 = "replayString3"; + String replayableReplayOther2 = "replayString2"; + String replaybleTargetOther1 = "replayTargetString1"; + String replaybleTargetOther2 = "replayTargetString2"; + MockReplayable replayableOther1 = new MockReplayable(replayableReplayOther1, + replaybleTargetOther1); + MockReplayable replayableOther2 = new MockReplayable(replayableReplayOther2, replaybleTargetOther2); + List replaySequenceOther = new LinkedList(); + replaySequenceOther.add(replayableOther1); + replaySequenceOther.add(replayableOther2); + ReplayableEvent other = new ReplayableEvent( + typeOther); + other.replayEvents = replaySequenceOther; + other.replayValid = replayValidOther; + + boolean result = fixture.equals(other); + + assertEquals(false, result); + } + + @Test + public void testEquals_4() throws Exception { + String type = "typeString"; + boolean replayValid = true; + String replayableReplay1 = "replayString1"; + String replayableReplay2 = "replayString2"; + String replayableTarget1 = "replayTargetString1"; + String replayableTarget2 = "replayTargetString2"; + MockReplayable replayable1 = new MockReplayable(replayableReplay1, + replayableTarget1); + MockReplayable replayable2 = new MockReplayable(replayableReplay2, replayableTarget2); + List replaySequence = new LinkedList(); + replaySequence.add(replayable1); + replaySequence.add(replayable2); + ReplayableEvent fixture = new ReplayableEvent( + type); + fixture.replayEvents = replaySequence; + fixture.replayValid = replayValid; + + String typeOther = "typeString"; + boolean replayValidOther = true; + String replayableReplayOther1 = "replayString1"; + String replayableReplayOther2 = "replayString3"; + String replaybleTargetOther1 = "replayTargetString1"; + String replaybleTargetOther2 = "replayTargetString2"; + MockReplayable replayableOther1 = new MockReplayable(replayableReplayOther1, + replaybleTargetOther1); + MockReplayable replayableOther2 = new MockReplayable(replayableReplayOther2, replaybleTargetOther2); + List replaySequenceOther = new LinkedList(); + replaySequenceOther.add(replayableOther1); + replaySequenceOther.add(replayableOther2); + ReplayableEvent other = new ReplayableEvent( + typeOther); + other.replayEvents = replaySequenceOther; + other.replayValid = replayValidOther; + + boolean result = fixture.equals(other); + + assertEquals(false, result); + } + + @Test + public void testEquals_5() throws Exception { + String type = "typeString"; + boolean replayValid = true; + String replayableReplay1 = "replayString1"; + String replayableReplay2 = "replayString2"; + String replayableTarget1 = "replayTargetString1"; + String replayableTarget2 = "replayTargetString2"; + MockReplayable replayable1 = new MockReplayable(replayableReplay1, + replayableTarget1); + MockReplayable replayable2 = new MockReplayable(replayableReplay2, replayableTarget2); + List replaySequence = new LinkedList(); + replaySequence.add(replayable1); + replaySequence.add(replayable2); + ReplayableEvent fixture = new ReplayableEvent( + type); + fixture.replayEvents = replaySequence; + fixture.replayValid = replayValid; + + String typeOther = "typeString"; + boolean replayValidOther = false; + String replayableReplayOther1 = "replayString1"; + String replayableReplayOther2 = "replayString2"; + String replaybleTargetOther1 = "replayTargetString1"; + String replaybleTargetOther2 = "replayTargetString2"; + MockReplayable replayableOther1 = new MockReplayable(replayableReplayOther1, + replaybleTargetOther1); + MockReplayable replayableOther2 = new MockReplayable(replayableReplayOther2, replaybleTargetOther2); + List replaySequenceOther = new LinkedList(); + replaySequenceOther.add(replayableOther1); + replaySequenceOther.add(replayableOther2); + ReplayableEvent other = new ReplayableEvent( + typeOther); + other.replayEvents = replaySequenceOther; + other.replayValid = replayValidOther; + + boolean result = fixture.equals(other); + + assertEquals(false, result); + } + + @Test + public void testEquals_6() throws Exception { + String type = "typeString"; + boolean replayValid = true; + String replayableReplay1 = "replayString1"; + String replayableReplay2 = "replayString2"; + String replayableTarget1 = "replayTargetString1"; + String replayableTarget2 = "replayTargetString2"; + MockReplayable replayable1 = new MockReplayable(replayableReplay1, + replayableTarget1); + MockReplayable replayable2 = new MockReplayable(replayableReplay2, replayableTarget2); + List replaySequence = new LinkedList(); + replaySequence.add(replayable1); + replaySequence.add(replayable2); + ReplayableEvent fixture = new ReplayableEvent( + type); + fixture.replayEvents = replaySequence; + fixture.replayValid = replayValid; + + boolean result = fixture.equals(fixture); + + assertEquals(true, result); + } + + @Test + public void testEqualsContract() throws Exception { + EqualsVerifier.forClass(ReplayableEvent.class) + .suppress(Warning.STRICT_INHERITANCE, Warning.NONFINAL_FIELDS).withRedefinedSuperclass() + .verify(); + } + + @Test + public void testGetReplayDecorator_1() throws Exception { + String type = "typeString"; + StubReplayDecorator decorator = new StubReplayDecorator(); + ReplayableEvent fixture = new ReplayableEvent( + type); + fixture.decorator = decorator; + + IReplayDecorator result = fixture.getReplayDecorator(); + + assertEquals(decorator, result); + } + + @Test + public void testGetReplayMessages_1() throws Exception { + String type = "typeString"; + String replayableReplay1 = "replayString1"; + String replayableReplay2 = "replayString2"; + String replayableTarget1 = "replayTargetString1"; + String replayableTarget2 = "replayTargetString2"; + MockReplayable replayable1 = new MockReplayable(replayableReplay1, + replayableTarget1); + MockReplayable replayable2 = new MockReplayable(replayableReplay2, replayableTarget2); + List replaySequence = new LinkedList(); + replaySequence.add(replayable1); + replaySequence.add(replayable2); + ReplayableEvent fixture = new ReplayableEvent( + type); + fixture.replayEvents = replaySequence; + + List result = fixture.getReplayMessages(); + + ListAssert.assertEquals(replaySequence, result); + } + + @Test + public void testHasValidReplay_1() throws Exception { + String type = "typeString"; + boolean replayValid = true; + ReplayableEvent fixture = new ReplayableEvent( + type); + fixture.replayValid = replayValid; + + boolean result = fixture.hasValidReplay(); + + assertEquals(replayValid, result); + } + + @Test + public void testHasValidReplay_2() throws Exception { + String type = "typeString"; + boolean replayValid = false; + ReplayableEvent fixture = new ReplayableEvent( + type); + fixture.replayValid = replayValid; + + boolean result = fixture.hasValidReplay(); + + assertEquals(replayValid, result); + } + + @Test + public void testInvalidateReplay_1() throws Exception { + String type = "typeString"; + ReplayableEvent fixture = new ReplayableEvent( + type); + + fixture.invalidateReplay(); + + assertFalse(fixture.replayValid); + } + + @Test + public void testInvalidateReplay_2() throws Exception { + String type = "typeString"; + ReplayableEvent fixture = new ReplayableEvent( + type); + + fixture.invalidateReplay(); + fixture.invalidateReplay(); + + assertFalse(fixture.replayValid); + } + + @Test + public void testSetDecorator_fixture_1() throws Exception { + String type = "typeString"; + StubReplayDecorator decorator = new StubReplayDecorator(); + ReplayableEvent fixture = new ReplayableEvent( + type); + + fixture.setDecorator(decorator); + + assertEquals(decorator, fixture.decorator); + } + + public static void main(String[] args) { + new org.junit.runner.JUnitCore().run(ReplayableEventTest.class); + } +} Index: /trunk/EventBenchCoreTest/src/de/ugoe/cs/eventbench/data/TestAll.java =================================================================== --- /trunk/EventBenchCoreTest/src/de/ugoe/cs/eventbench/data/TestAll.java (revision 338) +++ /trunk/EventBenchCoreTest/src/de/ugoe/cs/eventbench/data/TestAll.java (revision 338) @@ -0,0 +1,25 @@ +package de.ugoe.cs.eventbench.data; + +import org.junit.runner.JUnitCore; +import org.junit.runner.RunWith; +import org.junit.runners.Suite; + +/** + * The class TestAll builds a suite that can be used to run all + * of the tests within its package as well as within any subpackages of its + * package. + * + * @author Steffen Herbold + * @version 1.0 + */ +@RunWith(Suite.class) +@Suite.SuiteClasses({ + EventTest.class, + ReplayableEventTest.class +}) +public class TestAll { + + public static void main(String[] args) { + JUnitCore.runClasses(new Class[] { TestAll.class }); + } +}