diff --git a/src/main/java/com/team766/framework3/Rule.java b/src/main/java/com/team766/framework3/Rule.java index 5999e7f9..c76ae228 100644 --- a/src/main/java/com/team766/framework3/Rule.java +++ b/src/main/java/com/team766/framework3/Rule.java @@ -24,8 +24,8 @@ * public class MyRules extends RuleEngine { * public MyRules() { * // add rule to spin up the shooter when the boxop presses the right trigger on the gamepad - * rules.add(Rule.create("spin up shooter", gamepad.getButton(InputConstants.XBOX_RT)). - * withNewlyTriggeringProcedure(() -> new ShooterSpin(shooter))); + * rules.add("spin up shooter", gamepad.getButton(InputConstants.XBOX_RT), + * () -> new ShooterSpin(shooter))); * ... * } * } @@ -49,55 +49,6 @@ enum TriggerType { FINISHED } - /** - * Simple Builder for {@link Rule}s. Configure Rules via this Builder; these fields will be immutable - * in the rule the Builder constructs. - * - * Instances of this Builder are created via {@link Rule#create} to simplify syntax. - */ - public static class Builder { - private final String name; - private final BooleanSupplier predicate; - private Supplier newlyTriggeringProcedure; - private Supplier finishedTriggeringProcedure; - - private Builder(String name, BooleanSupplier predicate) { - this.name = name; - this.predicate = predicate; - } - - /** Specify a creator for the Procedure that should be run when this rule starts triggering. */ - public Builder withNewlyTriggeringProcedure(Supplier action) { - this.newlyTriggeringProcedure = action; - return this; - } - - public Builder withNewlyTriggeringProcedure( - Set> reservations, Runnable action) { - this.newlyTriggeringProcedure = - () -> new FunctionalInstantProcedure(reservations, action); - return this; - } - - /** Specify a creator for the Procedure that should be run when this rule was triggering before and is no longer triggering. */ - public Builder withFinishedTriggeringProcedure(Supplier action) { - this.finishedTriggeringProcedure = action; - return this; - } - - public Builder withFinishedTriggeringProcedure( - Set> reservations, Runnable action) { - this.finishedTriggeringProcedure = - () -> new FunctionalInstantProcedure(reservations, action); - return this; - } - - // called by {@link RuleEngine#addRule}. - /* package */ Rule build() { - return new Rule(name, predicate, newlyTriggeringProcedure, finishedTriggeringProcedure); - } - } - private final String name; private final BooleanSupplier predicate; private final Map> triggerProcedures = @@ -106,16 +57,10 @@ public Builder withFinishedTriggeringProcedure( Maps.newEnumMap(TriggerType.class); private TriggerType currentTriggerType = TriggerType.NONE; + private boolean sealed = false; - public static Builder create(String name, BooleanSupplier predicate) { - return new Builder(name, predicate); - } - - private Rule( - String name, - BooleanSupplier predicate, - Supplier newlyTriggeringProcedure, - Supplier finishedTriggeringProcedure) { + /* package */ Rule( + String name, BooleanSupplier predicate, Supplier newlyTriggeringProcedure) { if (predicate == null) { throw new IllegalArgumentException("Rule predicate has not been set."); } @@ -131,12 +76,23 @@ private Rule( triggerReservations.put( TriggerType.NEWLY, getReservationsForProcedure(newlyTriggeringProcedure)); } + } - if (finishedTriggeringProcedure != null) { - triggerProcedures.put(TriggerType.FINISHED, finishedTriggeringProcedure); - triggerReservations.put( - TriggerType.FINISHED, getReservationsForProcedure(finishedTriggeringProcedure)); + /** Specify a creator for the Procedure that should be run when this rule was triggering before and is no longer triggering. */ + public Rule withFinishedTriggeringProcedure(Supplier action) { + if (sealed) { + throw new IllegalStateException( + "Cannot modify rules once they've been evaluated in the RuleEngine"); } + + triggerProcedures.put(TriggerType.FINISHED, action); + triggerReservations.put(TriggerType.FINISHED, getReservationsForProcedure(action)); + return this; + } + + public Rule withFinishedTriggeringProcedure(Set> reservations, Runnable action) { + return withFinishedTriggeringProcedure( + () -> new FunctionalInstantProcedure(reservations, action)); } private Set> getReservationsForProcedure(Supplier supplier) { @@ -157,6 +113,10 @@ public String getName() { return currentTriggerType; } + /* package */ void seal() { + sealed = true; + } + /* package */ void reset() { currentTriggerType = TriggerType.NONE; } diff --git a/src/main/java/com/team766/framework3/RuleEngine.java b/src/main/java/com/team766/framework3/RuleEngine.java index 78d7ed3d..4556bdd8 100644 --- a/src/main/java/com/team766/framework3/RuleEngine.java +++ b/src/main/java/com/team766/framework3/RuleEngine.java @@ -10,10 +10,11 @@ import edu.wpi.first.wpilibj2.command.CommandScheduler; import java.util.HashMap; import java.util.HashSet; -import java.util.LinkedList; -import java.util.List; +import java.util.LinkedHashMap; import java.util.Map; import java.util.Set; +import java.util.function.BooleanSupplier; +import java.util.function.Supplier; /** * {@link RuleEngine}s manage and process a set of {@link Rule}s. Subclasses should add rules via @@ -30,9 +31,10 @@ public class RuleEngine implements LoggingBase { private static record RuleAction(Rule rule, Rule.TriggerType triggerType) {} - private final List rules = new LinkedList<>(); + private final LinkedHashMap rules = new LinkedHashMap<>(); private final Map rulePriorities = new HashMap<>(); private BiMap ruleMap = HashBiMap.create(); + private boolean sealed = false; protected RuleEngine() {} @@ -41,20 +43,28 @@ public Category getLoggerCategory() { return Category.RULES; } - protected void addRule(Rule.Builder builder) { - Rule rule = builder.build(); - rules.add(rule); + protected Rule addRule(String name, BooleanSupplier condition, Supplier action) { + Rule rule = new Rule(name, condition, action); + rules.put(name, rule); int priority = rulePriorities.size(); rulePriorities.put(rule, priority); + return rule; + } + + protected Rule addRule( + String name, BooleanSupplier condition, Mechanism mechanism, Runnable action) { + return addRule( + name, condition, () -> new FunctionalInstantProcedure(Set.of(mechanism), action)); } @VisibleForTesting - /* package */ Map getRuleNameMap() { - Map namedRules = new HashMap<>(); - for (Rule rule : rules) { - namedRules.put(rule.getName(), rule); - } - return namedRules; + /* package */ int size() { + return rules.size(); + } + + @VisibleForTesting + /* package */ Rule getRuleByName(String name) { + return rules.get(name); } @VisibleForTesting @@ -73,7 +83,18 @@ protected Rule getRuleForTriggeredProcedure(Command command) { return (ruleAction == null) ? null : ruleAction.rule; } + private void sealRules() { + for (Rule rule : rules.values()) { + rule.seal(); + } + } + public final void run() { + if (!sealed) { + sealRules(); + sealed = true; + } + Set> mechanismsToUse = new HashSet<>(); // TODO(MF3): when creating a Procedure, check that the reservations are the same as @@ -81,7 +102,7 @@ public final void run() { // evaluate each rule ruleLoop: - for (Rule rule : rules) { + for (Rule rule : rules.values()) { try { rule.evaluate(); diff --git a/src/test/java/com/team766/framework3/RuleEngineTest.java b/src/test/java/com/team766/framework3/RuleEngineTest.java index aa496c90..3c0b9edd 100644 --- a/src/test/java/com/team766/framework3/RuleEngineTest.java +++ b/src/test/java/com/team766/framework3/RuleEngineTest.java @@ -3,12 +3,12 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; import com.team766.TestCase3; import edu.wpi.first.wpilibj2.command.Command; import edu.wpi.first.wpilibj2.command.CommandScheduler; -import java.util.Map; import java.util.Set; import java.util.function.BooleanSupplier; import org.junit.jupiter.api.Test; @@ -58,6 +58,34 @@ public boolean getAsBoolean() { private final FakeMechanism2 fm2 = new FakeMechanism2(); private final FakeMechanism3 fm3 = new FakeMechanism3(); + @Test + public void testSeal() { + // test that we can modify rules before we call run + RuleEngine rulesOne = + new RuleEngine() { + { + addRule("rule1_1", () -> true, () -> Procedure.NO_OP) + .withFinishedTriggeringProcedure(() -> Procedure.NO_OP); + } + }; + rulesOne.run(); + + // test that + RuleEngine rulesTwo = + new RuleEngine() { + { + addRule("rule2_1", () -> true, () -> Procedure.NO_OP); + } + }; + rulesTwo.run(); + + assertThrows( + IllegalStateException.class, + () -> + rulesTwo.getRuleByName("rule2_1") + .withFinishedTriggeringProcedure(() -> Procedure.NO_OP)); + } + @Test public void testAddRuleAndGetPriority() { // simply test that rules we add are added - and at the expected priority @@ -67,22 +95,21 @@ public void testAddRuleAndGetPriority() { new RuleEngine() { { addRule( - Rule.create("fm1_p0", new ScheduledPredicate(0)) - .withNewlyTriggeringProcedure( - () -> new FakeProcedure(2, Set.of(fm1)))); + "fm1_p0", + new ScheduledPredicate(0), + () -> new FakeProcedure(2, Set.of(fm1))); addRule( - Rule.create("fm1_p1", new ScheduledPredicate(0)) - .withNewlyTriggeringProcedure( - () -> new FakeProcedure(2, Set.of(fm1)))); + "fm1_p1", + new ScheduledPredicate(0), + () -> new FakeProcedure(2, Set.of(fm1))); } }; - Map namedRules = myRules.getRuleNameMap(); // make sure we have 2 rules - assertEquals(2, namedRules.size()); + assertEquals(2, myRules.size()); // with priorities based on insertion order, starting at 0 - assertEquals(0, myRules.getPriorityForRule(namedRules.get("fm1_p0"))); - assertEquals(1, myRules.getPriorityForRule(namedRules.get("fm1_p1"))); + assertEquals(0, myRules.getPriorityForRule(myRules.getRuleByName("fm1_p0"))); + assertEquals(1, myRules.getPriorityForRule(myRules.getRuleByName("fm1_p1"))); } @Test @@ -96,13 +123,13 @@ public void testRunNonConflictingRules() { new RuleEngine() { { addRule( - Rule.create("fm1", new ScheduledPredicate(0)) - .withNewlyTriggeringProcedure( - () -> new FakeProcedure(2, Set.of(fm1)))); + "fm1", + new ScheduledPredicate(0), + () -> new FakeProcedure(2, Set.of(fm1))); addRule( - Rule.create("fm2", new ScheduledPredicate(0)) - .withNewlyTriggeringProcedure( - () -> new FakeProcedure(2, Set.of(fm2)))); + "fm2", + new ScheduledPredicate(0), + () -> new FakeProcedure(2, Set.of(fm2))); } }; @@ -146,17 +173,13 @@ public void testFinishedProcedureBumpsNewlyProcedureForSameRule() { new RuleEngine() { { addRule( - Rule.create("fm1_p0", new ScheduledPredicate(0)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procnew_p0", 1, Set.of(fm1))) - .withFinishedTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procfin_p0", - 1, - Set.of(fm1, fm2)))); + "fm1_p0", + new ScheduledPredicate(0), + () -> new FakeProcedure("fm1procnew_p0", 1, Set.of(fm1))) + .withFinishedTriggeringProcedure( + () -> + new FakeProcedure( + "fm1procfin_p0", 1, Set.of(fm1, fm2))); } }; @@ -188,28 +211,18 @@ public void testRunRulePriorities() { new RuleEngine() { { addRule( - Rule.create("fm1_p0", new ScheduledPredicate(0)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1proc_p0", - 0, - Set.of(fm1, fm2)))); + "fm1_p0", + new ScheduledPredicate(0), + () -> new FakeProcedure("fm1proc_p0", 0, Set.of(fm1, fm2))); addRule( - Rule.create("fm1_p1", new PeriodicPredicate(2)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1proc_p1", - 0, - Set.of(fm1, fm3)))); + "fm1_p1", + new PeriodicPredicate(2), + () -> new FakeProcedure("fm1proc_p1", 0, Set.of(fm1, fm3))); addRule( - Rule.create("fm3_p2", new ScheduledPredicate(0)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm3proc_p2", 0, Set.of(fm3)))); + "fm3_p2", + new ScheduledPredicate(0), + () -> new FakeProcedure("fm3proc_p2", 0, Set.of(fm3))); } }; @@ -250,30 +263,18 @@ public void testRunHigherPriorityRuleStillBeingRun() { new RuleEngine() { { addRule( - Rule.create("fm1_p0", new ScheduledPredicate(0)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1proc_p0", - 2, - Set.of(fm1, fm2)))); + "fm1_p0", + new ScheduledPredicate(0), + () -> new FakeProcedure("fm1proc_p0", 2, Set.of(fm1, fm2))); addRule( - Rule.create("fm1_p1", new ScheduledPredicate(1)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1proc_p1", - 2, - Set.of(fm1, fm2)))); + "fm1_p1", + new ScheduledPredicate(1), + () -> new FakeProcedure("fm1proc_p1", 2, Set.of(fm1, fm2))); addRule( - Rule.create("fm1_p2", new ScheduledPredicate(3)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1proc_p2", - 2, - Set.of(fm1, fm2)))); + "fm1_p2", + new ScheduledPredicate(3), + () -> new FakeProcedure("fm1proc_p2", 2, Set.of(fm1, fm2))); } }; @@ -321,21 +322,13 @@ public void testRunLowerPriorityRuleBumped() { new RuleEngine() { { addRule( - Rule.create("fm1_p0", new ScheduledPredicate(1)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1proc_p0", - 2, - Set.of(fm1, fm2)))); + "fm1_p0", + new ScheduledPredicate(1), + () -> new FakeProcedure("fm1proc_p0", 2, Set.of(fm1, fm2))); addRule( - Rule.create("fm1_p1", new ScheduledPredicate(0)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1proc_p1", - 4, - Set.of(fm1, fm2)))); + "fm1_p1", + new ScheduledPredicate(0), + () -> new FakeProcedure("fm1proc_p1", 4, Set.of(fm1, fm2))); } }; @@ -363,21 +356,15 @@ public void testRuleResetIgnoredLowerPriorityRule() { new RuleEngine() { { addRule( - Rule.create("fm1_p0", new ScheduledPredicate(0)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procnew_p0", 2, Set.of(fm1)))); + "fm1_p0", + new ScheduledPredicate(0), + () -> new FakeProcedure("fm1procnew_p0", 2, Set.of(fm1))); addRule( - Rule.create("fm1_p1", new ScheduledPredicate(0)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procnew_p1", 1, Set.of(fm1))) - .withFinishedTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procfin_p1", 1, Set.of(fm2)))); + "fm1_p1", + new ScheduledPredicate(0), + () -> new FakeProcedure("fm1procnew_p1", 1, Set.of(fm1))) + .withFinishedTriggeringProcedure( + () -> new FakeProcedure("fm1procfin_p1", 1, Set.of(fm2))); } }; @@ -404,21 +391,15 @@ public void testRuleResetIgnoredLowerPriorityRuleHigherPriorityRulePreviouslySch new RuleEngine() { { addRule( - Rule.create("fm1_p0", new ScheduledPredicate(0)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procnew_p0", 2, Set.of(fm1)))); + "fm1_p0", + new ScheduledPredicate(0), + () -> new FakeProcedure("fm1procnew_p0", 2, Set.of(fm1))); addRule( - Rule.create("fm1_p1", new ScheduledPredicate(1)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procnew_p1", 1, Set.of(fm1))) - .withFinishedTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procfin_p1", 1, Set.of(fm2)))); + "fm1_p1", + new ScheduledPredicate(1), + () -> new FakeProcedure("fm1procnew_p1", 1, Set.of(fm1))) + .withFinishedTriggeringProcedure( + () -> new FakeProcedure("fm1procfin_p1", 1, Set.of(fm2))); } }; @@ -453,21 +434,15 @@ public void testRuleResetBumpedLowerPriorityRule() { new RuleEngine() { { addRule( - Rule.create("fm1_p0", new ScheduledPredicate(1)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procnew_p0", 2, Set.of(fm1)))); + "fm1_p0", + new ScheduledPredicate(1), + () -> new FakeProcedure("fm1procnew_p0", 2, Set.of(fm1))); addRule( - Rule.create("fm1_p1", new ScheduledPredicate(0)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procnew_p1", 2, Set.of(fm1))) - .withFinishedTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procfin_p1", 2, Set.of(fm2)))); + "fm1_p1", + new ScheduledPredicate(0), + () -> new FakeProcedure("fm1procnew_p1", 2, Set.of(fm1))) + .withFinishedTriggeringProcedure( + () -> new FakeProcedure("fm1procfin_p1", 2, Set.of(fm2))); } }; @@ -494,25 +469,17 @@ public void testLowerPriorityRuleRunsWhenProcedureFromHigherPriorityRuleFinishes new RuleEngine() { { addRule( - Rule.create("fm1_p0", new ScheduledPredicate(0, 4)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procnew_p0", 0, Set.of(fm1))) - .withFinishedTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procfin_p0", 0, Set.of(fm1)))); + "fm1_p0", + new ScheduledPredicate(0, 4), + () -> new FakeProcedure("fm1procnew_p0", 0, Set.of(fm1))) + .withFinishedTriggeringProcedure( + () -> new FakeProcedure("fm1procfin_p0", 0, Set.of(fm1))); addRule( - Rule.create("fm1_p1", new ScheduledPredicate(1)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procnew_p1", 0, Set.of(fm1))) - .withFinishedTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procfin_p1", 0, Set.of(fm1)))); + "fm1_p1", + new ScheduledPredicate(1), + () -> new FakeProcedure("fm1procnew_p1", 0, Set.of(fm1))) + .withFinishedTriggeringProcedure( + () -> new FakeProcedure("fm1procfin_p1", 0, Set.of(fm1))); } }; @@ -563,25 +530,17 @@ public void testRuleCalledAgainAfterBeingReset() { new RuleEngine() { { addRule( - Rule.create("fm1_p0", new ScheduledPredicate(1)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procnew_p0", 0, Set.of(fm1))) - .withFinishedTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procfin_p0", 0, Set.of(fm1)))); + "fm1_p0", + new ScheduledPredicate(1), + () -> new FakeProcedure("fm1procnew_p0", 0, Set.of(fm1))) + .withFinishedTriggeringProcedure( + () -> new FakeProcedure("fm1procfin_p0", 0, Set.of(fm1))); addRule( - Rule.create("fm1_p1", new ScheduledPredicate(0, 4)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procnew_p1", 1, Set.of(fm1))) - .withFinishedTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procfin_p1", 1, Set.of(fm1)))); + "fm1_p1", + new ScheduledPredicate(0, 4), + () -> new FakeProcedure("fm1procnew_p1", 1, Set.of(fm1))) + .withFinishedTriggeringProcedure( + () -> new FakeProcedure("fm1procfin_p1", 1, Set.of(fm1))); } }; @@ -633,25 +592,17 @@ public void testRuleResetPreventsFinishedForLongTrigger() { new RuleEngine() { { addRule( - Rule.create("fm1_p0", new ScheduledPredicate(1)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procnew_p0", 0, Set.of(fm1))) - .withFinishedTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procfin_p0", 0, Set.of(fm1)))); + "fm1_p0", + new ScheduledPredicate(1), + () -> new FakeProcedure("fm1procnew_p0", 0, Set.of(fm1))) + .withFinishedTriggeringProcedure( + () -> new FakeProcedure("fm1procfin_p0", 0, Set.of(fm1))); addRule( - Rule.create("fm1_p1", new ScheduledPredicate(0, 3)) - .withNewlyTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procnew_p1", 1, Set.of(fm1))) - .withFinishedTriggeringProcedure( - () -> - new FakeProcedure( - "fm1procfin_p1", 1, Set.of(fm1)))); + "fm1_p1", + new ScheduledPredicate(0, 3), + () -> new FakeProcedure("fm1procnew_p1", 1, Set.of(fm1))) + .withFinishedTriggeringProcedure( + () -> new FakeProcedure("fm1procfin_p1", 1, Set.of(fm1))); } }; diff --git a/src/test/java/com/team766/framework3/RuleTest.java b/src/test/java/com/team766/framework3/RuleTest.java index 3b7730a8..b37a5425 100644 --- a/src/test/java/com/team766/framework3/RuleTest.java +++ b/src/test/java/com/team766/framework3/RuleTest.java @@ -41,10 +41,7 @@ protected void setUp() {} @Test public void testCreate() { - Rule alwaysTrue = - Rule.create("always true", () -> true) - .withNewlyTriggeringProcedure(() -> Procedure.NO_OP) - .build(); + Rule alwaysTrue = new Rule("always true", () -> true, () -> Procedure.NO_OP); assertNotNull(alwaysTrue); assertEquals("always true", alwaysTrue.getName()); } @@ -52,10 +49,7 @@ public void testCreate() { @Test public void testEvaluate() { // start with simple test of a NONE->NEWLY->CONTINUING->CONTINUING sequence - Rule alwaysTrue = - Rule.create("always true", () -> true) - .withNewlyTriggeringProcedure(() -> Procedure.NO_OP) - .build(); + Rule alwaysTrue = new Rule("always true", () -> true, () -> Procedure.NO_OP); assertEquals(Rule.TriggerType.NONE, alwaysTrue.getCurrentTriggerType()); alwaysTrue.evaluate(); assertEquals(TriggerType.NEWLY, alwaysTrue.getCurrentTriggerType()); @@ -66,9 +60,10 @@ public void testEvaluate() { // test a full cycle: NONE->NEWLY->CONTINUING->FINISHED->NONE->NEWLY->... Rule duckDuckGooseGoose = - Rule.create("duck duck goose goose", new DuckDuckGooseGoosePredicate()) - .withNewlyTriggeringProcedure(() -> Procedure.NO_OP) - .build(); + new Rule( + "duck duck goose goose", + new DuckDuckGooseGoosePredicate(), + () -> Procedure.NO_OP); assertEquals(Rule.TriggerType.NONE, duckDuckGooseGoose.getCurrentTriggerType()); duckDuckGooseGoose.evaluate(); assertEquals(TriggerType.NEWLY, duckDuckGooseGoose.getCurrentTriggerType()); @@ -89,10 +84,11 @@ public void testGetMechanismsToReserve() { final Set> finishedMechanisms = Set.of(new FakeMechanism()); Rule duckDuckGooseGoose = - Rule.create("duck duck goose goose", new DuckDuckGooseGoosePredicate()) - .withNewlyTriggeringProcedure(newlyMechanisms, () -> {}) - .withFinishedTriggeringProcedure(finishedMechanisms, () -> {}) - .build(); + new Rule( + "duck duck goose goose", + new DuckDuckGooseGoosePredicate(), + () -> new FunctionalInstantProcedure(newlyMechanisms, () -> {})) + .withFinishedTriggeringProcedure(finishedMechanisms, () -> {}); // NONE assertEquals(Collections.emptySet(), duckDuckGooseGoose.getMechanismsToReserve()); @@ -101,12 +97,13 @@ public void testGetMechanismsToReserve() { duckDuckGooseGoose.evaluate(); assertEquals(newlyMechanisms, duckDuckGooseGoose.getMechanismsToReserve()); - // nothing between NEWLLY and FINISHED + // nothing between NEWLY and FINISHED duckDuckGooseGoose.evaluate(); assertEquals(Collections.emptySet(), duckDuckGooseGoose.getMechanismsToReserve()); // FINISHED duckDuckGooseGoose.evaluate(); + System.out.println("X: " + duckDuckGooseGoose.toString()); assertEquals(finishedMechanisms, duckDuckGooseGoose.getMechanismsToReserve()); // check NONE again @@ -121,10 +118,11 @@ public void testGetMechanismsToReserve() { @Test public void testGetProcedureToRun() { Rule duckDuckGooseGoose = - Rule.create("duck duck goose goose", new DuckDuckGooseGoosePredicate()) - .withNewlyTriggeringProcedure(() -> new TrivialProcedure("newly")) - .withFinishedTriggeringProcedure(() -> new TrivialProcedure("finished")) - .build(); + new Rule( + "duck duck goose goose", + new DuckDuckGooseGoosePredicate(), + () -> new TrivialProcedure("newly")) + .withFinishedTriggeringProcedure(() -> new TrivialProcedure("finished")); // NONE assertNull(duckDuckGooseGoose.getProcedureToRun());