From 283eb3f938ff93150e855f119a04d9899e995ad9 Mon Sep 17 00:00:00 2001 From: Vladimir Dolzhenko Date: Fri, 14 Feb 2014 22:38:57 +0100 Subject: [PATCH] usage fixes: generics, context --- .../java/com/toddfast/mutagen/Mutation.java | 8 +- src/main/java/com/toddfast/mutagen/Plan.java | 22 +- .../java/com/toddfast/mutagen/Planner.java | 6 +- .../toddfast/mutagen/basic/BasicContext.java | 14 +- .../toddfast/mutagen/basic/BasicPlanner.java | 179 +++++++--------- .../mutagen/simple/BasicPlannerTest.java | 191 +++++++++--------- 6 files changed, 186 insertions(+), 234 deletions(-) diff --git a/src/main/java/com/toddfast/mutagen/Mutation.java b/src/main/java/com/toddfast/mutagen/Mutation.java index 467a637..923a381 100644 --- a/src/main/java/com/toddfast/mutagen/Mutation.java +++ b/src/main/java/com/toddfast/mutagen/Mutation.java @@ -3,7 +3,7 @@ /** * Represents a single change that can be made to a subject, identified * unambiguously by a state. - * + * * @author Todd Fast */ public interface Mutation> { @@ -33,20 +33,20 @@ public void mutate(Context context) * Context provided to an executing mutation * */ - public static interface Context { + public static interface Context> { /** * * */ - public Subject getSubject(); + public Subject getSubject(); /** * * */ - public Coordinator getCoordinator(); + public Coordinator getCoordinator(); /** diff --git a/src/main/java/com/toddfast/mutagen/Plan.java b/src/main/java/com/toddfast/mutagen/Plan.java index f189780..ba3a95a 100644 --- a/src/main/java/com/toddfast/mutagen/Plan.java +++ b/src/main/java/com/toddfast/mutagen/Plan.java @@ -2,9 +2,11 @@ import java.util.List; +import com.toddfast.mutagen.Mutation.Context; + /** * A prepared plan for mutating the target subject through a sequence of states - * + * * @author Todd Fast */ public interface Plan> { @@ -15,34 +17,27 @@ public interface Plan> { */ public Subject getSubject(); - /** * * */ public Coordinator getCoordinator(); - /** * * */ public List> getMutations(); - /** * * */ - public Result execute() - throws MutagenException; - - + public Result execute(Context context) throws MutagenException; - - //////////////////////////////////////////////////////////////////////////// + // ////////////////////////////////////////////////////////////////////////// // Types - //////////////////////////////////////////////////////////////////////////// + // ////////////////////////////////////////////////////////////////////////// /** * @@ -56,35 +51,30 @@ public static interface Result> { */ public Plan getPlan(); - /** * * */ public boolean isMutationComplete(); - /** * * */ public > State getLastState(); - /** * * */ public List> getCompletedMutations(); - /** * * */ public List> getRemainingMutations(); - /** * * diff --git a/src/main/java/com/toddfast/mutagen/Planner.java b/src/main/java/com/toddfast/mutagen/Planner.java index 2df0085..953a97a 100644 --- a/src/main/java/com/toddfast/mutagen/Planner.java +++ b/src/main/java/com/toddfast/mutagen/Planner.java @@ -1,9 +1,11 @@ package com.toddfast.mutagen; +import com.toddfast.mutagen.Mutation.Context; + /** * Produces plans that can be executed to mutate the target subject to a given * state, using the coordinator to accept or reject mutations. - * + * * @author Todd Fast */ public interface Planner> { @@ -12,5 +14,5 @@ public interface Planner> { * * */ - public Plan getPlan(Subject subject, Coordinator coordinator); + public Plan getPlan(Context context); } diff --git a/src/main/java/com/toddfast/mutagen/basic/BasicContext.java b/src/main/java/com/toddfast/mutagen/basic/BasicContext.java index c19fc1b..8a82d1c 100644 --- a/src/main/java/com/toddfast/mutagen/basic/BasicContext.java +++ b/src/main/java/com/toddfast/mutagen/basic/BasicContext.java @@ -7,16 +7,16 @@ /** * Implements the basic contract of {@link Mutation.Context}. Logs to * {@link System.out} and {@link System.err}. - * + * * @author Todd Fast */ -public class BasicContext implements Mutation.Context { +public class BasicContext> implements Mutation.Context { /** * * */ - public BasicContext(Subject subject, Coordinator coordinator) { + public BasicContext(Subject subject, Coordinator coordinator) { super(); this.subject=subject; this.coordinator=coordinator; @@ -28,7 +28,7 @@ public BasicContext(Subject subject, Coordinator coordinator) { * */ @Override - public Subject getSubject() { + public Subject getSubject() { return subject; } @@ -38,7 +38,7 @@ public Subject getSubject() { * */ @Override - public Coordinator getCoordinator() { + public Coordinator getCoordinator() { return coordinator; } @@ -79,6 +79,6 @@ public void error(String message, Object... parameters) { // Fields //////////////////////////////////////////////////////////////////////////// - private Subject subject; - private Coordinator coordinator; + private Subject subject; + private Coordinator coordinator; } diff --git a/src/main/java/com/toddfast/mutagen/basic/BasicPlanner.java b/src/main/java/com/toddfast/mutagen/basic/BasicPlanner.java index 346b513..3f4cf9b 100644 --- a/src/main/java/com/toddfast/mutagen/basic/BasicPlanner.java +++ b/src/main/java/com/toddfast/mutagen/basic/BasicPlanner.java @@ -1,39 +1,38 @@ package com.toddfast.mutagen.basic; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Iterator; +import java.util.List; + import com.toddfast.mutagen.Coordinator; +import com.toddfast.mutagen.MutagenException; import com.toddfast.mutagen.Mutation; import com.toddfast.mutagen.Mutation.Context; -import com.toddfast.mutagen.MutagenException; import com.toddfast.mutagen.Plan; -import com.toddfast.mutagen.Plan.Result; import com.toddfast.mutagen.Planner; import com.toddfast.mutagen.State; import com.toddfast.mutagen.Subject; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.Comparator; -import java.util.Iterator; -import java.util.List; /** * Generates basic plans using the initial list of mutations and the specified * subject and coordinator. The list of mutations is cloned and cannot be * modified after creation. - * + * * @author Todd Fast */ -public class BasicPlanner> implements Planner { +public class BasicPlanner> implements Planner { /** * * */ public BasicPlanner(Collection> allMutations) { - this(allMutations,null); + this( allMutations, null ); } - /** * * @@ -41,95 +40,73 @@ public BasicPlanner(Collection> allMutations) { public BasicPlanner(Collection> allMutations, Comparator> comparator) { super(); - this.mutations=new ArrayList>(allMutations); - if (comparator!=null) { - Collections.sort(this.mutations,comparator); + this.mutations = new ArrayList>( allMutations ); + if ( comparator != null ) { + Collections.sort( this.mutations, comparator ); } } - /** * * */ @Override - public Plan getPlan(Subject subject, Coordinator coordinator) { + public Plan getPlan(Context context) { + Coordinator coordinator = context.getCoordinator(); + Subject subject = context.getSubject(); - List> subjectMutations= - new ArrayList>(mutations); + List> subjectMutations = new ArrayList>( mutations ); // Filter out the mutations that are unacceptable to the subject - for (Iterator> i=subjectMutations.iterator(); - i.hasNext(); ) { + for ( Iterator> i = subjectMutations.iterator(); i.hasNext(); ) { - Mutation mutation=i.next(); - if (!coordinator.accept(subject,mutation.getResultingState())) { + Mutation mutation = i.next(); + if ( !coordinator.accept( subject, mutation.getResultingState() ) ) { i.remove(); } } - return new BasicPlan(subject,coordinator,subjectMutations); + return new BasicPlan( subject, coordinator, subjectMutations ); } - /** * * */ - private BasicResult executePlan(BasicPlan plan) { - - List> completedMutations=new ArrayList>(); - List> remainingMutations= - new ArrayList>(plan.getMutations()); - MutagenException exception=null; + private BasicResult executePlan(Context context, BasicPlan plan) { - Context context=createContext( - plan.getSubject(),plan.getCoordinator()); + List> completedMutations = new ArrayList>(); + List> remainingMutations = new ArrayList>( plan.getMutations() ); + MutagenException exception = null; Mutation mutation; - State lastState=null; - for (Iterator> - i=remainingMutations.iterator(); i.hasNext(); ) { - - mutation=i.next(); + State lastState = null; + for ( Iterator> i = remainingMutations.iterator(); i.hasNext(); ) { + mutation = i.next(); try { - mutation.mutate(context); + mutation.mutate( context ); - lastState=mutation.getResultingState(); + lastState = mutation.getResultingState(); // Add to the completed list, remove from remaining list - completedMutations.add(mutation); + completedMutations.add( mutation ); i.remove(); - } - catch (RuntimeException e) { - exception=new MutagenException("Exception executing "+ - "mutation for state \""+mutation.getResultingState()+ - "\"",e); + } catch ( RuntimeException e ) { + exception = new MutagenException( "Exception executing " + + "mutation for state \"" + + mutation.getResultingState() + "\"", e ); break; } } - return new BasicResult(plan,plan.getSubject(), - completedMutations,remainingMutations,lastState,exception); + return new BasicResult( plan, plan.getSubject(), completedMutations, + remainingMutations, lastState, exception ); } - - /** - * - * - */ - protected Context createContext(Subject subject, - Coordinator coordinator) { - return new BasicContext(subject,coordinator); - } - - - - - //////////////////////////////////////////////////////////////////////////// + // ////////////////////////////////////////////////////////////////////////// // Types - //////////////////////////////////////////////////////////////////////////// + // ////////////////////////////////////////////////////////////////////////// /** * @@ -144,9 +121,9 @@ public class BasicPlan implements com.toddfast.mutagen.Plan { private BasicPlan(Subject subject, Coordinator coordinator, List> mutations) { super(); - this.subject=subject; - this.coordinator=coordinator; - this.mutations=mutations; + this.subject = subject; + this.coordinator = coordinator; + this.mutations = mutations; } /** @@ -173,7 +150,7 @@ public Coordinator getCoordinator() { */ @Override public List> getMutations() { - return Collections.unmodifiableList(mutations); + return Collections.unmodifiableList( mutations ); } /** @@ -181,22 +158,18 @@ public List> getMutations() { * */ @Override - public Result execute() - throws MutagenException { - return BasicPlanner.this.executePlan(this); + public Result execute(Context context) throws MutagenException { + return BasicPlanner.this.executePlan( context, this ); } - private Subject subject; - private Coordinator coordinator; - private List> mutations; + private Subject subject; + private Coordinator coordinator; + private List> mutations; } - - - - //////////////////////////////////////////////////////////////////////////// + // ////////////////////////////////////////////////////////////////////////// // Types - //////////////////////////////////////////////////////////////////////////// + // ////////////////////////////////////////////////////////////////////////// /** * @@ -208,19 +181,17 @@ public class BasicResult implements com.toddfast.mutagen.Plan.Result { * * */ - private BasicResult(BasicPlan plan, - Subject subject, + private BasicResult(BasicPlan plan, Subject subject, List> completedMutations, - List> remainingMutations, - State lastState, + List> remainingMutations, State lastState, MutagenException exception) { super(); - this.plan=plan; - this.subject=subject; - this.completedMutations=completedMutations; - this.remainingMutations=remainingMutations; - this.lastState=lastState; - this.exception=exception; + this.plan = plan; + this.subject = subject; + this.completedMutations = completedMutations; + this.remainingMutations = remainingMutations; + this.lastState = lastState; + this.exception = exception; } /** @@ -241,7 +212,6 @@ public boolean isMutationComplete() { return remainingMutations.isEmpty(); } - /** * * @@ -251,7 +221,6 @@ public State getLastState() { return lastState; } - /** * * @@ -261,7 +230,6 @@ public List> getCompletedMutations() { return completedMutations; } - /** * * @@ -271,7 +239,6 @@ public List> getRemainingMutations() { return remainingMutations; } - /** * * @@ -281,29 +248,25 @@ public MutagenException getException() { return exception; } - - private BasicPlan plan; - private Subject subject; - private List> completedMutations; - private List> remainingMutations; - private State lastState; - private MutagenException exception; + private BasicPlan plan; + private Subject subject; + private List> completedMutations; + private List> remainingMutations; + private State lastState; + private MutagenException exception; } - - - - //////////////////////////////////////////////////////////////////////////// + // ////////////////////////////////////////////////////////////////////////// // Fields - //////////////////////////////////////////////////////////////////////////// + // ////////////////////////////////////////////////////////////////////////// - public static final Comparator> COMPARATOR= + public static final Comparator> COMPARATOR = new Comparator>() { @Override - public int compare(Mutation m1, Mutation m2) { - return m1.getResultingState().compareTo(m2.getResultingState()); + public int compare( Mutation m1, Mutation m2) { + return m1.getResultingState().compareTo(m2.getResultingState() ); } }; - private List> mutations; + private List> mutations; } diff --git a/src/test/java/com/toddfast/mutagen/simple/BasicPlannerTest.java b/src/test/java/com/toddfast/mutagen/simple/BasicPlannerTest.java index 02392c6..1e5baf6 100644 --- a/src/test/java/com/toddfast/mutagen/simple/BasicPlannerTest.java +++ b/src/test/java/com/toddfast/mutagen/simple/BasicPlannerTest.java @@ -1,12 +1,23 @@ package com.toddfast.mutagen.simple; -import com.toddfast.mutagen.basic.BasicPlanner; -import com.toddfast.mutagen.basic.MonotonicVersionCoordinator; +import java.util.ArrayList; +import java.util.List; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; + import com.toddfast.mutagen.Coordinator; import com.toddfast.mutagen.Mutation; +import com.toddfast.mutagen.Mutation.Context; import com.toddfast.mutagen.Plan; import com.toddfast.mutagen.Plan.Result; import com.toddfast.mutagen.Planner; +import com.toddfast.mutagen.basic.BasicContext; +import com.toddfast.mutagen.basic.BasicPlanner; +import com.toddfast.mutagen.basic.MonotonicVersionCoordinator; import com.toddfast.mutagen.simple.test.mutations.java.Buffer; import com.toddfast.mutagen.simple.test.mutations.java.Counter; import com.toddfast.mutagen.simple.test.mutations.java.Mutation1; @@ -15,14 +26,8 @@ import com.toddfast.mutagen.simple.test.mutations.java.MutationA; import com.toddfast.mutagen.simple.test.mutations.java.MutationB; import com.toddfast.mutagen.simple.test.mutations.java.MutationC; -import java.util.ArrayList; -import java.util.List; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; -import static org.junit.Assert.*; + +import static org.junit.Assert.assertEquals; /** * @@ -34,52 +39,47 @@ public class BasicPlannerTest { public BasicPlannerTest() { } - @BeforeClass public static void setUpClass() { } - @AfterClass public static void tearDownClass() { } - @Before public void setUp() { } - @After public void tearDown() { } - /** * - * + * */ @Test public void testGetPlan() { - List> mutations=new ArrayList>(); + List> mutations = new ArrayList>(); - mutations.add(new Mutation1()); - mutations.add(new Mutation2()); - mutations.add(new Mutation3()); + mutations.add( new Mutation1() ); + mutations.add( new Mutation2() ); + mutations.add( new Mutation3() ); - Planner planner=new BasicPlanner(mutations); - Counter subject=new Counter(0); - Coordinator coordinator= - new MonotonicVersionCoordinator(); + Planner planner = new BasicPlanner( mutations ); + Counter subject = new Counter( 0 ); + Coordinator coordinator = new MonotonicVersionCoordinator(); - Plan plan=planner.getPlan(subject,coordinator); + Context context = new BasicContext( subject, coordinator ); - Result result=plan.execute(); + Plan plan = planner.getPlan( context ); - assertEquals((int)subject.getCurrentState().getID(),3); - } + Result result = plan.execute( context ); + assertEquals( (int) subject.getCurrentState().getID(), 3 ); + } /** * @@ -88,25 +88,24 @@ public void testGetPlan() { @Test public void testGetPlan2() { - List> mutations=new ArrayList>(); + List> mutations = new ArrayList>(); - mutations.add(new Mutation1()); - mutations.add(new Mutation2()); - mutations.add(new Mutation3()); + mutations.add( new Mutation1() ); + mutations.add( new Mutation2() ); + mutations.add( new Mutation3() ); - Planner planner=new BasicPlanner(mutations); - Counter subject=new Counter(1); - Coordinator coordinator= - new MonotonicVersionCoordinator(); + Planner planner = new BasicPlanner( mutations ); + Counter subject = new Counter( 1 ); + Coordinator coordinator = new MonotonicVersionCoordinator(); + Context context = new BasicContext( subject, coordinator ); - Plan plan=planner.getPlan(subject,coordinator); + Plan plan = planner.getPlan( context ); - Result result=plan.execute(); + Result result = plan.execute(context); - assertEquals((int)subject.getCurrentState().getID(),3); + assertEquals( (int) subject.getCurrentState().getID(), 3 ); } - /** * * @@ -114,25 +113,24 @@ public void testGetPlan2() { @Test public void testGetPlan3() { - List> mutations=new ArrayList>(); + List> mutations = new ArrayList>(); - mutations.add(new Mutation1()); - mutations.add(new Mutation2()); - mutations.add(new Mutation3()); + mutations.add( new Mutation1() ); + mutations.add( new Mutation2() ); + mutations.add( new Mutation3() ); - Planner planner=new BasicPlanner(mutations); - Counter subject=new Counter(2); - Coordinator coordinator= - new MonotonicVersionCoordinator(); + Planner planner = new BasicPlanner( mutations ); + Counter subject = new Counter( 2 ); + Coordinator coordinator = new MonotonicVersionCoordinator(); + Context context = new BasicContext( subject, coordinator ); - Plan plan=planner.getPlan(subject,coordinator); + Plan plan = planner.getPlan( context ); - Result result=plan.execute(); + Result result = plan.execute( context ); - assertEquals((int)subject.getCurrentState().getID(),3); + assertEquals( (int) subject.getCurrentState().getID(), 3 ); } - /** * * @@ -140,25 +138,24 @@ public void testGetPlan3() { @Test public void testGetPlan4() { - List> mutations=new ArrayList>(); + List> mutations = new ArrayList>(); - mutations.add(new Mutation1()); - mutations.add(new Mutation2()); - mutations.add(new Mutation3()); + mutations.add( new Mutation1() ); + mutations.add( new Mutation2() ); + mutations.add( new Mutation3() ); - Planner planner=new BasicPlanner(mutations); - Counter subject=new Counter(3); - Coordinator coordinator= - new MonotonicVersionCoordinator(); + Planner planner = new BasicPlanner( mutations ); + Counter subject = new Counter( 3 ); + Coordinator coordinator = new MonotonicVersionCoordinator(); + Context context = new BasicContext( subject, coordinator ); - Plan plan=planner.getPlan(subject,coordinator); + Plan plan = planner.getPlan(context); - Result result=plan.execute(); + Result result = plan.execute(context); - assertEquals((int)subject.getCurrentState().getID(),3); + assertEquals( (int) subject.getCurrentState().getID(), 3 ); } - /** * * @@ -166,25 +163,24 @@ public void testGetPlan4() { @Test public void testGetPlan5() { - List> mutations=new ArrayList>(); + List> mutations = new ArrayList>(); - mutations.add(new Mutation1()); - mutations.add(new Mutation2()); - mutations.add(new Mutation3()); + mutations.add( new Mutation1() ); + mutations.add( new Mutation2() ); + mutations.add( new Mutation3() ); - Planner planner=new BasicPlanner(mutations); - Counter subject=new Counter(4); - Coordinator coordinator= - new MonotonicVersionCoordinator(); + Planner planner = new BasicPlanner( mutations ); + Counter subject = new Counter( 4 ); + Coordinator coordinator = new MonotonicVersionCoordinator(); + Context context = new BasicContext( subject, coordinator ); - Plan plan=planner.getPlan(subject,coordinator); + Plan plan = planner.getPlan(context); - Result result=plan.execute(); + Result result = plan.execute(context); - assertEquals((int)subject.getCurrentState().getID(),4); + assertEquals( (int) subject.getCurrentState().getID(), 4 ); } - /** * * @@ -192,23 +188,23 @@ public void testGetPlan5() { @Test public void testBuffer1() { - List> mutations=new ArrayList>(); + List> mutations = new ArrayList>(); - mutations.add(new MutationA()); - mutations.add(new MutationB()); - mutations.add(new MutationC()); + mutations.add( new MutationA() ); + mutations.add( new MutationB() ); + mutations.add( new MutationC() ); - Planner planner=new BasicPlanner(mutations); - Buffer subject=new Buffer(""); - Coordinator coordinator=new DumbStringCoordinator(); - Plan plan=planner.getPlan(subject,coordinator); + Planner planner = new BasicPlanner( mutations ); + Buffer subject = new Buffer( "" ); + Coordinator coordinator = new DumbStringCoordinator(); + Context context = new BasicContext( subject, coordinator ); + Plan plan = planner.getPlan(context); - Result result=plan.execute(); + Result result = plan.execute(context); - assertEquals("abc",subject.getCurrentState().getID()); + assertEquals( "abc", subject.getCurrentState().getID() ); } - /** * * @@ -216,20 +212,21 @@ public void testBuffer1() { @Test public void testBuffer2() { - List> mutations=new ArrayList>(); + List> mutations = new ArrayList>(); - mutations.add(new MutationA()); - mutations.add(new MutationB()); - mutations.add(new MutationC()); + mutations.add( new MutationA() ); + mutations.add( new MutationB() ); + mutations.add( new MutationC() ); - Planner planner=new BasicPlanner(mutations); + Planner planner = new BasicPlanner( mutations ); - Buffer subject=new Buffer("a"); - Coordinator coordinator=new DumbStringCoordinator(); - Plan plan=planner.getPlan(subject,coordinator); + Buffer subject = new Buffer( "a" ); + Coordinator coordinator = new DumbStringCoordinator(); + Context context = new BasicContext( subject, coordinator ); + Plan plan = planner.getPlan(context); - Result result=plan.execute(); + Result result = plan.execute(context); - assertEquals("abc",subject.getCurrentState().getID()); + assertEquals( "abc", subject.getCurrentState().getID() ); } }