diff --git a/README.md b/README.md index 3f07fee1..f47fe1b0 100644 --- a/README.md +++ b/README.md @@ -44,14 +44,21 @@ a link to this page somewhere in the documentation/system about section. ## Change Log for the BPjs Library. +### 2019-02-04 +* :arrow_up: :tada: Event selection strategies now accept `BProgramSyncSnapshot`, rather than a set of sync statements and external events. + +### 2019-02-04 +* :sparkles: Testing infrastructure for execution traces. +* :arrow_up: More terminology cleanups in the api (e.g. "bsync" converted to "sync") + +### 2019-02-03 +* :arrow_up: `VisitedStateStore` now stores *states*, not DFS nodes. So it's more reusable that way. + ### 2019-01-19 * :sparkles: More tests. * :arrow_up: `BriefPrintDfsVerifierListener` => `PrintDfsVerifierListener`, so that it's consistent with `PrintBProgramRunnerListener`. * :arrow_up: Incorporated the "BPjs Tips" file to the central documentation. -### 2019-02-03 -* :arrow_up: `VisitedStateStore` now stores *states*, not DFS nodes. So it's more reusable that way. - ### 2019-01-18 * :bug: Fixed a that cause equality tests of JS event sets to return false negatives. * :bug: The `bp` object no longer collected by the state comparators. diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/analysis/DfsCycleInspection.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/analysis/DfsCycleInspection.java index 760cca8c..66ec4856 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/analysis/DfsCycleInspection.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/analysis/DfsCycleInspection.java @@ -42,7 +42,7 @@ public interface DfsCycleInspection { * * [a]-[b]-[c]-[d]--... * \ | - * +-----+ + * +-----+ (going from d back to b) * * * This methods will be called with trace={@code [a][b][c][d]} and diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/analysis/DfsInspections.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/analysis/DfsInspections.java index cc6a0695..f18ba4a6 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/analysis/DfsInspections.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/analysis/DfsInspections.java @@ -81,7 +81,7 @@ public final class DfsInspections { if ( curNode.getSystemState().isHot() && curNode.getSelectableEvents().isEmpty() ) { Set hotlyTerminated = curNode.getSystemState().getBThreadSnapshots().stream() - .filter( s -> s.getBSyncStatement().isHot() ).map( s->s.getName() ).collect( toSet() ); + .filter( s -> s.getSyncStatement().isHot() ).map( s->s.getName() ).collect( toSet() ); return Optional.of( new HotTerminationViolation(hotlyTerminated, trace) ); } else return Optional.empty(); }; @@ -123,7 +123,7 @@ public Optional inspectCycle(List currentTrace, int } private Set getHotThreadNames( Set bts ) { - return bts.stream().filter( bt -> bt.getBSyncStatement().isHot() ) + return bts.stream().filter( bt -> bt.getSyncStatement().isHot() ) .map( bt -> bt.getName() ) .collect( toSet() ); } @@ -139,7 +139,7 @@ private Set getHotThreadNames( Set bts ) { // Utility methods. private static boolean hasRequestedEvents(BProgramSyncSnapshot bpss) { - return bpss.getBThreadSnapshots().stream().anyMatch(btss -> (!btss.getBSyncStatement().getRequest().isEmpty())); + return bpss.getBThreadSnapshots().stream().anyMatch(btss -> (!btss.getSyncStatement().getRequest().isEmpty())); } private static DfsTraversalNode peek(List trace) { diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/analysis/DfsTraversalNode.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/analysis/DfsTraversalNode.java index e2188306..bcdbefbd 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/analysis/DfsTraversalNode.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/analysis/DfsTraversalNode.java @@ -48,8 +48,7 @@ protected DfsTraversalNode(BProgram bp, BProgramSyncSnapshot systemState, BEvent this.lastEvent = e; if (bp != null) { - selectableEvents = bp.getEventSelectionStrategy().selectableEvents(systemState.getStatements(), - systemState.getExternalEvents()); + selectableEvents = bp.getEventSelectionStrategy().selectableEvents(systemState); ArrayList eventOrdered = new ArrayList<>(selectableEvents); Collections.shuffle(eventOrdered); iterator = eventOrdered.iterator(); @@ -64,7 +63,7 @@ private String stateString() { StringBuilder str = new StringBuilder(); systemState.getBThreadSnapshots().forEach( - s -> str.append("\t").append(s.toString()).append(" {").append(s.getBSyncStatement()).append("} \n")); + s -> str.append("\t").append(s.toString()).append(" {").append(s.getSyncStatement()).append("} \n")); return str.toString(); } diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/bprogramio/BProgramSyncSnapshotIO.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/bprogramio/BProgramSyncSnapshotIO.java index fe36ed2a..5ff25aa6 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/bprogramio/BProgramSyncSnapshotIO.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/bprogramio/BProgramSyncSnapshotIO.java @@ -181,7 +181,7 @@ private void writeBThreadSnapshot(BThreadSyncSnapshot bss, ObjectOutputStream ou try (BThreadSyncSnapshotOutputStream btos = new BThreadSyncSnapshotOutputStream(bthreadBytes, scope)) { btos.writeObject(bss.getEntryPoint()); btos.writeObject(bss.getInterrupt().orElse(null)); - btos.writeObject(bss.getBSyncStatement()); + btos.writeObject(bss.getSyncStatement()); btos.writeObject(bss.getContinuation()); btos.flush(); diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/execution/BProgramRunner.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/execution/BProgramRunner.java index 4bd4d1ef..030f988a 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/execution/BProgramRunner.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/execution/BProgramRunner.java @@ -94,7 +94,7 @@ public void run() { while ( (!cur.noBThreadsLeft()) && go.get() ) { // see which events are selectable - Set possibleEvents = bprog.getEventSelectionStrategy().selectableEvents(cur.getStatements(), cur.getExternalEvents()); + Set possibleEvents = bprog.getEventSelectionStrategy().selectableEvents(cur); if ( possibleEvents.isEmpty() ) { // Superstep done: No events available for selection. @@ -115,7 +115,7 @@ public void run() { } else { // we can select some events - select one and advance. - Optional res = bprog.getEventSelectionStrategy().select(cur.getStatements(), cur.getExternalEvents(), possibleEvents); + Optional res = bprog.getEventSelectionStrategy().select(cur, possibleEvents); if ( res.isPresent() ) { EventSelectionResult esr = res.get(); diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/BProgramSyncSnapshot.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/BProgramSyncSnapshot.java index 18750ac9..89a43237 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/BProgramSyncSnapshot.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/BProgramSyncSnapshot.java @@ -142,7 +142,7 @@ public BProgramSyncSnapshot triggerEvent(BEvent anEvent, ExecutorService exSvc, // Split threads to those that advance this round and those that sleep. threadSnapshots.forEach( snapshot -> { - (snapshot.getBSyncStatement().shouldWakeFor(anEvent) ? resumingThisRound : sleepingThisRound).add(snapshot); + (snapshot.getSyncStatement().shouldWakeFor(anEvent) ? resumingThisRound : sleepingThisRound).add(snapshot); }); } finally { Context.exit(); @@ -183,7 +183,7 @@ public BProgramSyncSnapshot triggerEvent(BEvent anEvent, ExecutorService exSvc, private void handleInterrupts(BEvent anEvent, Iterable listeners, BProgram bprog, Context ctxt) { Set interrupted = threadSnapshots.stream() - .filter(bt -> bt.getBSyncStatement().getInterrupt().contains(anEvent)) + .filter(bt -> bt.getSyncStatement().getInterrupt().contains(anEvent)) .collect(toSet()); if (!interrupted.isEmpty()) { threadSnapshots.removeAll(interrupted); @@ -211,7 +211,7 @@ public Set getBThreadSnapshots() { } public Set getStatements() { - return getBThreadSnapshots().stream().map(BThreadSyncSnapshot::getBSyncStatement) + return getBThreadSnapshots().stream().map(BThreadSyncSnapshot::getSyncStatement) .collect(toSet()); } @@ -256,7 +256,7 @@ public FailedAssertion getFailedAssertion() { */ public boolean isHot() { return getBThreadSnapshots().stream() - .map(BThreadSyncSnapshot::getBSyncStatement) + .map(BThreadSyncSnapshot::getSyncStatement) .filter(SyncStatement::isHot) .findAny().isPresent(); } diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/BThreadSyncSnapshot.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/BThreadSyncSnapshot.java index 7cefd4a4..73a2594a 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/BThreadSyncSnapshot.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/BThreadSyncSnapshot.java @@ -88,11 +88,11 @@ public BThreadSyncSnapshot copyWith(Object aContinuation, SyncStatement aStateme return retVal; } - public SyncStatement getBSyncStatement() { + public SyncStatement getSyncStatement() { return bSyncStatement; } - public void setBSyncStatement(SyncStatement stmt) { + public void setSyncStatement(SyncStatement stmt) { bSyncStatement = stmt; if (bSyncStatement.getBthread() != this) { bSyncStatement.setBthread(this); diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/AbstractEventSelectionStrategy.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/AbstractEventSelectionStrategy.java index ec677b46..2c3f2717 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/AbstractEventSelectionStrategy.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/AbstractEventSelectionStrategy.java @@ -25,6 +25,7 @@ import il.ac.bgu.cs.bp.bpjs.model.SyncStatement; import il.ac.bgu.cs.bp.bpjs.model.BEvent; +import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot; import il.ac.bgu.cs.bp.bpjs.model.eventsets.EventSet; import java.util.ArrayList; import static java.util.Collections.singleton; @@ -65,18 +66,17 @@ public long getSeed() { /** * Randomly select an event from {@code selectableEvents}, or a non-blocked event from {@code externalEvents}, in case {@code selectableEvents} is empty. * - * @param statements Statements at the current {@code bsync}. - * @param externalEvents List of events that are not requested by b-threads (at least, not directly). + * @param bpss a b-program at synchronization point. * @param selectableEvents Set of events that can be selected. * @return An optional event selection result. */ @Override - public Optional select(Set statements, List externalEvents, Set selectableEvents) { + public Optional select(BProgramSyncSnapshot bpss, Set selectableEvents) { if (selectableEvents.isEmpty()) { return Optional.empty(); } BEvent chosen = new ArrayList<>(selectableEvents).get(rnd.nextInt(selectableEvents.size())); - Set requested = statements.stream() + Set requested = bpss.getStatements().stream() .filter((SyncStatement stmt) -> stmt != null) .flatMap((SyncStatement stmt) -> stmt.getRequest().stream()) .collect(Collectors.toSet()); @@ -85,7 +85,7 @@ public Optional select(Set statements, List return Optional.of(new EventSelectionResult(chosen)); } else { // that was an external event, need to find the first index - return Optional.of(new EventSelectionResult(chosen, singleton(externalEvents.indexOf(chosen)))); + return Optional.of(new EventSelectionResult(chosen, singleton(bpss.getExternalEvents().indexOf(chosen)))); } } diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/AbstractEventSelectionStrategyDecorator.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/AbstractEventSelectionStrategyDecorator.java index fecfbd4f..c34b4f0c 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/AbstractEventSelectionStrategyDecorator.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/AbstractEventSelectionStrategyDecorator.java @@ -24,8 +24,7 @@ package il.ac.bgu.cs.bp.bpjs.model.eventselection; import il.ac.bgu.cs.bp.bpjs.model.BEvent; -import il.ac.bgu.cs.bp.bpjs.model.SyncStatement; -import java.util.List; +import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot; import java.util.Optional; import java.util.Set; @@ -50,13 +49,13 @@ public ESS getDecorated() { } @Override - public Set selectableEvents(Set statements, List externalEvents) { - return getDecorated().selectableEvents(statements, externalEvents); + public Set selectableEvents(BProgramSyncSnapshot bpss) { + return getDecorated().selectableEvents(bpss); } @Override - public Optional select(Set statements, List externalEvents, Set selectableEvents) { - return getDecorated().select(statements, externalEvents, selectableEvents); + public Optional select(BProgramSyncSnapshot bpss, Set selectableEvents) { + return getDecorated().select(bpss, selectableEvents); } } diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/EventSelectionStrategy.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/EventSelectionStrategy.java index e3178c7d..5eadc761 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/EventSelectionStrategy.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/EventSelectionStrategy.java @@ -2,6 +2,7 @@ import il.ac.bgu.cs.bp.bpjs.model.SyncStatement; import il.ac.bgu.cs.bp.bpjs.model.BEvent; +import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot; import java.util.List; import java.util.Optional; import java.util.Set; @@ -19,25 +20,32 @@ public interface EventSelectionStrategy { /** - * Creates the set of selectable events, given the {@link SyncStatement}s from - * all participating BThreads. - * @param statements statements of all participating BThreads. - * @param externalEvents events queued by external processes. + * Creates the set of selectable events, given a b-program's + * synchronization point. + * + * @param bpss a {@link BProgram} at a synchronization point. * @return A set of events that may be selected for execution. */ - Set selectableEvents(Set statements, List externalEvents); + Set selectableEvents(BProgramSyncSnapshot bpss); /** * Selects an event for execution from the parameter {@code selectableEvents}, * or returns {@link Optional#empty()} in case no suitable event is found. * - * @param statements statements of all participating BThreads. - * @param externalEvents events queued by external processes. - * @param selectableEvents A set of events to select from + * The {@code selectableEvents} set is Normally the set of + * events returned by {@code this}' {@link #selectableEvents(il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot)} + * method on the previous call on the same synchronization point. This is + * an optimization that allows most strategies to select events only once + * per synchronization point. + * + * In normal BP, the selected event (if any) has + * to be a member of {@code selectableEvents}. + * + * @param bpss a {@link BProgram} at a synchronization point. + * @param selectableEvents A set of events to select from. * @return An event selection result, or no result. */ - Optional select(Set statements, - List externalEvents, + Optional select(BProgramSyncSnapshot bpss, Set selectableEvents ); } diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/LoggingEventSelectionStrategyDecorator.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/LoggingEventSelectionStrategyDecorator.java index afb3eb4b..aca90629 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/LoggingEventSelectionStrategyDecorator.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/LoggingEventSelectionStrategyDecorator.java @@ -23,11 +23,10 @@ */ package il.ac.bgu.cs.bp.bpjs.model.eventselection; -import il.ac.bgu.cs.bp.bpjs.model.SyncStatement; import il.ac.bgu.cs.bp.bpjs.model.BEvent; +import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot; import java.io.PrintStream; import java.io.PrintWriter; -import java.util.List; import java.util.Optional; import java.util.Set; @@ -53,19 +52,19 @@ public LoggingEventSelectionStrategyDecorator(ESS decorated) { } @Override - public Set selectableEvents(Set statements, List externalEvents) { - final Set selectableEvents = getDecorated().selectableEvents(statements, externalEvents); + public Set selectableEvents(BProgramSyncSnapshot bpss) { + final Set selectableEvents = getDecorated().selectableEvents(bpss); out.println("== Choosing Selectable Events =="); out.println("BThread Sync Statements:"); - statements.forEach( stmt -> { + bpss.getStatements().forEach( stmt -> { out.println("+ " + stmt.getBthread().getName() + ":" + (stmt.isHot()?" HOT":"")); out.println(" Request: " + stmt.getRequest()); out.println(" WaitFor: " + stmt.getWaitFor()); out.println(" Block: " + stmt.getBlock()); out.println(" Interrupt: " + stmt.getInterrupt()); }); - out.println("+ ExternalEvents: " + externalEvents); + out.println("+ ExternalEvents: " + bpss.getExternalEvents()); out.println("-- Selectable Events -----------"); if ( selectableEvents.isEmpty() ){ @@ -80,8 +79,8 @@ public Set selectableEvents(Set statements, List } @Override - public Optional select(Set statements, List externalEvents, Set selectableEvents) { - Optional selectedEvent = getDecorated().select(statements, externalEvents, selectableEvents); + public Optional select(BProgramSyncSnapshot bpss, Set selectableEvents) { + Optional selectedEvent = getDecorated().select(bpss, selectableEvents); out.println("== Actual Event Selection ======"); out.println( selectedEvent.toString() ); out.println("================================"); diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/OrderedEventSelectionStrategy.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/OrderedEventSelectionStrategy.java index 32a0ce7b..107b7efa 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/OrderedEventSelectionStrategy.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/OrderedEventSelectionStrategy.java @@ -25,6 +25,7 @@ import il.ac.bgu.cs.bp.bpjs.model.SyncStatement; import il.ac.bgu.cs.bp.bpjs.model.BEvent; +import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot; import il.ac.bgu.cs.bp.bpjs.model.eventsets.ComposableEventSet; import il.ac.bgu.cs.bp.bpjs.model.eventsets.EventSet; import il.ac.bgu.cs.bp.bpjs.model.eventsets.EventSets; @@ -50,7 +51,10 @@ public class OrderedEventSelectionStrategy extends AbstractEventSelectionStrategy { @Override - public Set selectableEvents(Set statements, List externalEvents) { + public Set selectableEvents(BProgramSyncSnapshot bpss) { + Set statements = bpss.getStatements(); + List externalEvents = bpss.getExternalEvents(); + if ( statements.isEmpty() ) { // Corner case, not sure this is even possible. return externalEvents.isEmpty() ? emptySet() : singleton(externalEvents.get(0)); diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PausingEventSelectionStrategyDecorator.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PausingEventSelectionStrategyDecorator.java index 7a75a699..af3584ca 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PausingEventSelectionStrategyDecorator.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PausingEventSelectionStrategyDecorator.java @@ -25,8 +25,7 @@ import il.ac.bgu.cs.bp.bpjs.model.BEvent; import il.ac.bgu.cs.bp.bpjs.model.BProgram; -import il.ac.bgu.cs.bp.bpjs.model.SyncStatement; -import java.util.List; +import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot; import java.util.Optional; import java.util.Set; import java.util.concurrent.locks.ReadWriteLock; @@ -61,8 +60,8 @@ public PausingEventSelectionStrategyDecorator(ESS decorated) { } @Override - public Optional select(Set statements, List externalEvents, Set selectableEvents) { - Optional res = getDecorated().select(statements, externalEvents, selectableEvents); + public Optional select(BProgramSyncSnapshot bpss, Set selectableEvents) { + Optional res = getDecorated().select(bpss, selectableEvents); lock.readLock().lock(); listener.eventSelectionPaused(this); lock.writeLock().lock(); // blocks while the read lock is locked. diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PrioritizedBSyncEventSelectionStrategy.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PrioritizedBSyncEventSelectionStrategy.java index 5de024b0..498cd662 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PrioritizedBSyncEventSelectionStrategy.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PrioritizedBSyncEventSelectionStrategy.java @@ -25,6 +25,7 @@ import il.ac.bgu.cs.bp.bpjs.model.SyncStatement; import il.ac.bgu.cs.bp.bpjs.model.BEvent; +import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot; import il.ac.bgu.cs.bp.bpjs.model.eventsets.ComposableEventSet; import il.ac.bgu.cs.bp.bpjs.model.eventsets.EventSet; import il.ac.bgu.cs.bp.bpjs.model.eventsets.EventSets; @@ -57,7 +58,10 @@ public PrioritizedBSyncEventSelectionStrategy() { } @Override - public Set selectableEvents(Set statements, List externalEvents) { + public Set selectableEvents(BProgramSyncSnapshot bpss) { + + Set statements = bpss.getStatements(); + List externalEvents = bpss.getExternalEvents(); EventSet blocked = ComposableEventSet.anyOf(statements.stream() .filter( stmt -> stmt!=null ) diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PrioritizedBThreadsEventSelectionStrategy.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PrioritizedBThreadsEventSelectionStrategy.java index 22316ac5..5afde4ed 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PrioritizedBThreadsEventSelectionStrategy.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PrioritizedBThreadsEventSelectionStrategy.java @@ -6,7 +6,6 @@ import static java.util.stream.Collectors.toSet; import java.util.HashMap; -import java.util.List; import java.util.Map; import java.util.Set; import java.util.stream.Collectors; @@ -15,12 +14,14 @@ import il.ac.bgu.cs.bp.bpjs.model.SyncStatement; import il.ac.bgu.cs.bp.bpjs.model.BEvent; +import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot; import il.ac.bgu.cs.bp.bpjs.model.eventsets.ComposableEventSet; import il.ac.bgu.cs.bp.bpjs.model.eventsets.EventSet; import il.ac.bgu.cs.bp.bpjs.model.eventsets.EventSets; import java.util.Collection; import java.util.Collections; import java.util.Comparator; +import java.util.List; import java.util.stream.Stream; /** @@ -46,7 +47,10 @@ public PrioritizedBThreadsEventSelectionStrategy() { } @Override - public Set selectableEvents(Set statements, List externalEvents) { + public Set selectableEvents(BProgramSyncSnapshot bpss) { + Set statements = bpss.getStatements(); + List externalEvents = bpss.getExternalEvents(); + if ( statements.isEmpty() ) { // Corner case, not sure this is even possible. return externalEvents.isEmpty() ? emptySet() : singleton(externalEvents.get(0)); diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/SimpleEventSelectionStrategy.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/SimpleEventSelectionStrategy.java index c4128c97..e90212d7 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/SimpleEventSelectionStrategy.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/SimpleEventSelectionStrategy.java @@ -2,6 +2,7 @@ import il.ac.bgu.cs.bp.bpjs.model.SyncStatement; import il.ac.bgu.cs.bp.bpjs.model.BEvent; +import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot; import il.ac.bgu.cs.bp.bpjs.model.eventsets.ComposableEventSet; import il.ac.bgu.cs.bp.bpjs.model.eventsets.EventSet; import il.ac.bgu.cs.bp.bpjs.model.eventsets.EventSets; @@ -36,7 +37,9 @@ public SimpleEventSelectionStrategy() {} @Override - public Set selectableEvents(Set statements, List externalEvents) { + public Set selectableEvents(BProgramSyncSnapshot bpss) { + Set statements = bpss.getStatements(); + List externalEvents = bpss.getExternalEvents(); if ( statements.isEmpty() ) { // Corner case, not sure this is even possible. return externalEvents.isEmpty() ? emptySet() : singleton(externalEvents.get(0)); diff --git a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/internal/ContinuationProgramState.java b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/internal/ContinuationProgramState.java index d0355380..ef63b432 100644 --- a/src/main/java/il/ac/bgu/cs/bp/bpjs/model/internal/ContinuationProgramState.java +++ b/src/main/java/il/ac/bgu/cs/bp/bpjs/model/internal/ContinuationProgramState.java @@ -56,15 +56,19 @@ * @author michael */ public class ContinuationProgramState { - private final Map variables = new HashMap<>(); - private int programCounter = -1; - private int frameIndex = -1; + protected final Map variables = new HashMap<>(); + protected int programCounter = -1; + protected int frameIndex = -1; public ContinuationProgramState( NativeContinuation nc ) { collectStatus(nc.getImplementation()); collectScopeValues(nc); } + protected ContinuationProgramState(){ + // extra C'tor for subclasses. + } + private void collectScopeValues(NativeContinuation nc ){ ScriptableObject current = nc; ScriptableObject currentScope = nc; @@ -189,7 +193,7 @@ public boolean equals(Object obj) { if (obj == null) { return false; } - if (getClass() != obj.getClass()) { + if ( ! (obj instanceof ContinuationProgramState) ) { return false; } final ContinuationProgramState other = (ContinuationProgramState) obj; diff --git a/src/test/java/il/ac/bgu/cs/bp/bpjs/TestUtils.java b/src/test/java/il/ac/bgu/cs/bp/bpjs/TestUtils.java index 7d14b004..20bd82e8 100644 --- a/src/test/java/il/ac/bgu/cs/bp/bpjs/TestUtils.java +++ b/src/test/java/il/ac/bgu/cs/bp/bpjs/TestUtils.java @@ -26,8 +26,18 @@ import il.ac.bgu.cs.bp.bpjs.model.BEvent; import il.ac.bgu.cs.bp.bpjs.analysis.DfsTraversalNode; import il.ac.bgu.cs.bp.bpjs.analysis.VerificationResult; +import il.ac.bgu.cs.bp.bpjs.mocks.MockBProgramSyncSnapshot; +import il.ac.bgu.cs.bp.bpjs.model.BProgram; +import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot; +import il.ac.bgu.cs.bp.bpjs.model.BThreadSyncSnapshot; +import il.ac.bgu.cs.bp.bpjs.model.StringBProgram; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashSet; import java.util.List; import java.util.Objects; +import java.util.Set; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; import static java.util.stream.Collectors.joining; @@ -71,4 +81,16 @@ public static T safeGet( Future f ) { throw new RuntimeException(ex); } } + + public static BProgramSyncSnapshot makeBPSS( BThreadSyncSnapshot... snapshots ) { + Set bts = new HashSet<>(); + bts.addAll(Arrays.asList(snapshots)); + return makeBPSS( bts ); + } + + public static BProgramSyncSnapshot makeBPSS( Collection snapshots ) { + BProgram bprog = new StringBProgram(""); + Set bts = new HashSet<>(snapshots); + return new MockBProgramSyncSnapshot(new BProgramSyncSnapshot(bprog, bts, Collections.emptyList(), null)); + } } diff --git a/src/test/java/il/ac/bgu/cs/bp/bpjs/analysis/examples/DiningPhilTest.java b/src/test/java/il/ac/bgu/cs/bp/bpjs/analysis/examples/DiningPhilTest.java index 25cff583..00a08eae 100644 --- a/src/test/java/il/ac/bgu/cs/bp/bpjs/analysis/examples/DiningPhilTest.java +++ b/src/test/java/il/ac/bgu/cs/bp/bpjs/analysis/examples/DiningPhilTest.java @@ -38,7 +38,7 @@ private static void printCounterExample(VerificationResult res) { .sorted((s1, s2) -> s1.getName().compareTo(s2.getName())) .forEach(s -> { System.out.println(s.getName()); - System.out.println(s.getBSyncStatement()); + System.out.println(s.getSyncStatement()); System.out.println(); }); } diff --git a/src/test/java/il/ac/bgu/cs/bp/bpjs/execution/jsproxy/SyncStatementTempTest.java b/src/test/java/il/ac/bgu/cs/bp/bpjs/execution/jsproxy/SyncStatementTempTest.java index 138769d4..e94b4fbf 100644 --- a/src/test/java/il/ac/bgu/cs/bp/bpjs/execution/jsproxy/SyncStatementTempTest.java +++ b/src/test/java/il/ac/bgu/cs/bp/bpjs/execution/jsproxy/SyncStatementTempTest.java @@ -28,6 +28,7 @@ import il.ac.bgu.cs.bp.bpjs.execution.listeners.PrintBProgramRunnerListener; import il.ac.bgu.cs.bp.bpjs.model.BEvent; import il.ac.bgu.cs.bp.bpjs.model.BProgram; +import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot; import il.ac.bgu.cs.bp.bpjs.model.ResourceBProgram; import il.ac.bgu.cs.bp.bpjs.model.SyncStatement; import il.ac.bgu.cs.bp.bpjs.model.eventselection.AbstractEventSelectionStrategyDecorator; @@ -55,9 +56,9 @@ public TemperatureLoggingESS(EventSelectionStrategy decorated) { } @Override - public Set selectableEvents(Set statements, List externalEvents) { - isHotRecord.add(statements.stream().filter(SyncStatement::isHot).findAny().isPresent()); - return decorated.selectableEvents(statements, externalEvents); + public Set selectableEvents(BProgramSyncSnapshot bpss) { + isHotRecord.add(bpss.getStatements().stream().filter(SyncStatement::isHot).findAny().isPresent()); + return decorated.selectableEvents(bpss); } } diff --git a/src/test/java/il/ac/bgu/cs/bp/bpjs/mocks/MockBProgramSyncSnapshot.java b/src/test/java/il/ac/bgu/cs/bp/bpjs/mocks/MockBProgramSyncSnapshot.java new file mode 100644 index 00000000..40d61c76 --- /dev/null +++ b/src/test/java/il/ac/bgu/cs/bp/bpjs/mocks/MockBProgramSyncSnapshot.java @@ -0,0 +1,39 @@ +/* + * The MIT License + * + * Copyright 2019 michael. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package il.ac.bgu.cs.bp.bpjs.mocks; + +import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot; +import java.util.ArrayList; + +/** + * + * @author michael + */ +public class MockBProgramSyncSnapshot extends BProgramSyncSnapshot { + + public MockBProgramSyncSnapshot(BProgramSyncSnapshot bpss) { + super(bpss.getBProgram(), bpss.getBThreadSnapshots(), new ArrayList<>(bpss.getExternalEvents()), bpss.getFailedAssertion()); + } + +} diff --git a/src/test/java/il/ac/bgu/cs/bp/bpjs/mocks/MockBThreadSyncSnapshot.java b/src/test/java/il/ac/bgu/cs/bp/bpjs/mocks/MockBThreadSyncSnapshot.java new file mode 100644 index 00000000..e513db75 --- /dev/null +++ b/src/test/java/il/ac/bgu/cs/bp/bpjs/mocks/MockBThreadSyncSnapshot.java @@ -0,0 +1,74 @@ +package il.ac.bgu.cs.bp.bpjs.mocks; + + +import il.ac.bgu.cs.bp.bpjs.model.BThreadSyncSnapshot; +import il.ac.bgu.cs.bp.bpjs.model.SyncStatement; +import il.ac.bgu.cs.bp.bpjs.model.internal.ContinuationProgramState; +import java.util.concurrent.atomic.AtomicInteger; + +/* + * The MIT License + * + * Copyright 2019 michael. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +/** + * + * @author michael + */ +public class MockBThreadSyncSnapshot extends BThreadSyncSnapshot { + + private static final AtomicInteger NEXT_ID = new AtomicInteger(0); + + public static class MockContinuationProgramState extends ContinuationProgramState { + + public void setFrameIndex(int frameIndex) { + this.frameIndex = frameIndex; + } + + public void setProgramCounter(int programCounter) { + this.programCounter = programCounter; + } + + public void setVariable( String name, Object value ) { + variables.put(name, value); + } + } + + public MockBThreadSyncSnapshot(String aName, SyncStatement stmt ) { + super(aName, null); + setSyncStatement(stmt); + stmt.setBthread(this); + } + + public MockBThreadSyncSnapshot(SyncStatement stmt ) { + this( "mock-btss_" + NEXT_ID.incrementAndGet(), stmt ); + } + + @Override + public ContinuationProgramState getContinuationProgramState() { + return super.getContinuationProgramState(); + } + + + + +} diff --git a/src/test/java/il/ac/bgu/cs/bp/bpjs/model/BProgramSyncSnapshotTest.java b/src/test/java/il/ac/bgu/cs/bp/bpjs/model/BProgramSyncSnapshotTest.java index 2c9a488c..66e4beb5 100644 --- a/src/test/java/il/ac/bgu/cs/bp/bpjs/model/BProgramSyncSnapshotTest.java +++ b/src/test/java/il/ac/bgu/cs/bp/bpjs/model/BProgramSyncSnapshotTest.java @@ -75,8 +75,8 @@ public void testDoubleTriggerEvent() throws InterruptedException { BProgramSyncSnapshot setup = bprog.setup(); ExecutorService execSvcA = ExecutorServiceMaker.makeWithName("BProgramSnapshotTriggerTest"); BProgramSyncSnapshot stepa = setup.start(execSvcA); - Set possibleEvents_a = bprog.getEventSelectionStrategy().selectableEvents(stepa.getStatements(), stepa.getExternalEvents()); - EventSelectionResult event_a = bprog.getEventSelectionStrategy().select(stepa.getStatements(), stepa.getExternalEvents(), possibleEvents_a).get(); + Set possibleEvents_a = bprog.getEventSelectionStrategy().selectableEvents(stepa); + EventSelectionResult event_a = bprog.getEventSelectionStrategy().select(stepa, possibleEvents_a).get(); stepa.triggerEvent(event_a.getEvent(), execSvcA, listeners); exception.expect(IllegalStateException.class); stepa.triggerEvent(event_a.getEvent(), execSvcA, listeners); @@ -92,8 +92,8 @@ public void testHotnessDetection() throws InterruptedException { ExecutorService execSvcA = ExecutorServiceMaker.makeWithName("BProgramSnapshotTriggerTest"); BProgramSyncSnapshot bpss = setup.start(execSvcA); assertFalse(bpss.isHot()); - Set possibleEvents_a = bprog.getEventSelectionStrategy().selectableEvents(bpss.getStatements(), bpss.getExternalEvents()); - EventSelectionResult event_a = bprog.getEventSelectionStrategy().select(bpss.getStatements(), bpss.getExternalEvents(), possibleEvents_a).get(); + Set possibleEvents_a = bprog.getEventSelectionStrategy().selectableEvents(bpss); + EventSelectionResult event_a = bprog.getEventSelectionStrategy().select(bpss, possibleEvents_a).get(); bpss = bpss.triggerEvent(event_a.getEvent(), execSvcA, listeners); assertTrue(bpss.isHot()); @@ -133,20 +133,20 @@ public void testEqualsSingleStep() throws InterruptedException { assertNotEquals(setup2, stepb); //run second step - Set possibleEvents_a = bprog.getEventSelectionStrategy().selectableEvents(stepa.getStatements(), stepa.getExternalEvents()); - Set possibleEvents_b = bprog2.getEventSelectionStrategy().selectableEvents(stepb.getStatements(), stepb.getExternalEvents()); - EventSelectionResult event_a = bprog.getEventSelectionStrategy().select(stepa.getStatements(), stepa.getExternalEvents(), possibleEvents_a).get(); - EventSelectionResult event_b = bprog2.getEventSelectionStrategy().select(stepa.getStatements(), stepb.getExternalEvents(), possibleEvents_b).get(); + Set possibleEvents_a = bprog.getEventSelectionStrategy().selectableEvents(stepa); + Set possibleEvents_b = bprog2.getEventSelectionStrategy().selectableEvents(stepb); + EventSelectionResult event_a = bprog.getEventSelectionStrategy().select(stepa, possibleEvents_a).get(); + EventSelectionResult event_b = bprog2.getEventSelectionStrategy().select(stepa, possibleEvents_b).get(); BProgramSyncSnapshot step2a = stepa.triggerEvent(event_a.getEvent(), execSvcA, listeners); BProgramSyncSnapshot step2b = stepb.triggerEvent(event_b.getEvent(), execSvcB, listeners); assertEquals(step2a, step2b); assertNotEquals(stepa, step2a); assertNotEquals(stepb, step2b); - possibleEvents_a = bprog.getEventSelectionStrategy().selectableEvents(step2a.getStatements(), step2a.getExternalEvents()); - possibleEvents_b = bprog2.getEventSelectionStrategy().selectableEvents(step2b.getStatements(), step2b.getExternalEvents()); - event_a = bprog.getEventSelectionStrategy().select(step2a.getStatements(), step2a.getExternalEvents(), possibleEvents_a).get(); - event_b = bprog2.getEventSelectionStrategy().select(step2b.getStatements(), step2b.getExternalEvents(), possibleEvents_b).get(); + possibleEvents_a = bprog.getEventSelectionStrategy().selectableEvents(step2a); + possibleEvents_b = bprog2.getEventSelectionStrategy().selectableEvents(step2b); + event_a = bprog.getEventSelectionStrategy().select(step2a, possibleEvents_a).get(); + event_b = bprog2.getEventSelectionStrategy().select(step2b, possibleEvents_b).get(); BProgramSyncSnapshot step3a = step2a.triggerEvent(event_a.getEvent(), execSvcA, listeners); BProgramSyncSnapshot step3b = step2b.triggerEvent(event_b.getEvent(), execSvcB, listeners); assertEquals(step3a, step3b); @@ -188,10 +188,10 @@ public void testEqualsSingleStepAssert() throws InterruptedException { assertNotEquals(setup2, postStart2); // Run second step - Set possibleEvents1 = bprog1.getEventSelectionStrategy().selectableEvents(postStart1.getStatements(), postStart1.getExternalEvents()); - Set possibleEvents2 = bprog2.getEventSelectionStrategy().selectableEvents(postStart2.getStatements(), postStart2.getExternalEvents()); - EventSelectionResult event1_1 = bprog1.getEventSelectionStrategy().select(postStart1.getStatements(), postStart1.getExternalEvents(), possibleEvents1).get(); - EventSelectionResult event1_2 = bprog2.getEventSelectionStrategy().select(postStart1.getStatements(), postStart2.getExternalEvents(), possibleEvents2).get(); + Set possibleEvents1 = bprog1.getEventSelectionStrategy().selectableEvents(postStart1); + Set possibleEvents2 = bprog2.getEventSelectionStrategy().selectableEvents(postStart2); + EventSelectionResult event1_1 = bprog1.getEventSelectionStrategy().select(postStart1, possibleEvents1).get(); + EventSelectionResult event1_2 = bprog2.getEventSelectionStrategy().select(postStart1, possibleEvents2).get(); BProgramSyncSnapshot postSync1_1 = postStart1.triggerEvent(event1_1.getEvent(), execSvcA, listeners); BProgramSyncSnapshot postSync1_2 = postStart2.triggerEvent(event1_2.getEvent(), execSvcB, listeners); assertTrue(postSync1_1.isStateValid()); @@ -199,10 +199,10 @@ public void testEqualsSingleStepAssert() throws InterruptedException { assertNotEquals(postStart1, postSync1_1); assertNotEquals(postStart2, postSync1_2); - possibleEvents1 = bprog1.getEventSelectionStrategy().selectableEvents(postSync1_1.getStatements(), postSync1_1.getExternalEvents()); - possibleEvents2 = bprog2.getEventSelectionStrategy().selectableEvents(postSync1_2.getStatements(), postSync1_2.getExternalEvents()); - EventSelectionResult event2_1 = bprog1.getEventSelectionStrategy().select(postSync1_1.getStatements(), postSync1_1.getExternalEvents(), possibleEvents1).get(); - EventSelectionResult event2_2 = bprog2.getEventSelectionStrategy().select(postSync1_2.getStatements(), postSync1_2.getExternalEvents(), possibleEvents2).get(); + possibleEvents1 = bprog1.getEventSelectionStrategy().selectableEvents(postSync1_1); + possibleEvents2 = bprog2.getEventSelectionStrategy().selectableEvents(postSync1_2); + EventSelectionResult event2_1 = bprog1.getEventSelectionStrategy().select(postSync1_1, possibleEvents1).get(); + EventSelectionResult event2_2 = bprog2.getEventSelectionStrategy().select(postSync1_2, possibleEvents2).get(); assertEquals("B", event2_1.getEvent().name); BProgramSyncSnapshot postSync2_1 = postSync1_1.triggerEvent(event2_1.getEvent(), execSvcA, listeners); diff --git a/src/test/java/il/ac/bgu/cs/bp/bpjs/model/BThreadSyncSnapshotTest.java b/src/test/java/il/ac/bgu/cs/bp/bpjs/model/BThreadSyncSnapshotTest.java index 04f6063a..84022a5a 100644 --- a/src/test/java/il/ac/bgu/cs/bp/bpjs/model/BThreadSyncSnapshotTest.java +++ b/src/test/java/il/ac/bgu/cs/bp/bpjs/model/BThreadSyncSnapshotTest.java @@ -58,14 +58,14 @@ public void testJSVarState() throws InterruptedException { snapshots.add(step); //Iteration 1, starts already at request state A for (int i = 0; i < 4; i++) { - Set possibleEvents_a = bprog.getEventSelectionStrategy().selectableEvents(step.getStatements(), step.getExternalEvents()); - EventSelectionResult event_a = bprog.getEventSelectionStrategy().select(step.getStatements(), step.getExternalEvents(), possibleEvents_a).get(); + Set possibleEvents_a = bprog.getEventSelectionStrategy().selectableEvents(step); + EventSelectionResult event_a = bprog.getEventSelectionStrategy().select(step, possibleEvents_a).get(); step = step.triggerEvent(event_a.getEvent(), execSvc, listeners); } snapshots.add(step); for (int i = 0; i < 4; i++) { - Set possibleEvents_a = bprog.getEventSelectionStrategy().selectableEvents(step.getStatements(), step.getExternalEvents()); - EventSelectionResult event_a = bprog.getEventSelectionStrategy().select(step.getStatements(), step.getExternalEvents(), possibleEvents_a).get(); + Set possibleEvents_a = bprog.getEventSelectionStrategy().selectableEvents(step); + EventSelectionResult event_a = bprog.getEventSelectionStrategy().select(step, possibleEvents_a).get(); step = step.triggerEvent(event_a.getEvent(), execSvc, listeners); } snapshots.add(step); @@ -86,8 +86,8 @@ public void testJavaVarState() throws InterruptedException { BProgramSyncSnapshot postSetup = bprog.setup(); ExecutorService execSvcA = ExecutorServiceMaker.makeWithName("BProgramSnapshotTriggerTest"); BProgramSyncSnapshot postSync1 = postSetup.start(execSvcA); - Set possibleEvents = bprog.getEventSelectionStrategy().selectableEvents(postSync1.getStatements(), postSync1.getExternalEvents()); - EventSelectionResult esr = bprog.getEventSelectionStrategy().select(postSync1.getStatements(), postSync1.getExternalEvents(), possibleEvents).get(); + Set possibleEvents = bprog.getEventSelectionStrategy().selectableEvents(postSync1); + EventSelectionResult esr = bprog.getEventSelectionStrategy().select(postSync1, possibleEvents).get(); BProgramSyncSnapshot postSync2 = postSync1.triggerEvent(esr.getEvent(), execSvcA, listeners); assertNotEquals(postSync1.getBThreadSnapshots(), postSync2.getBThreadSnapshots()); diff --git a/src/test/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/OrderedEventSelectionStrategyTest.java b/src/test/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/OrderedEventSelectionStrategyTest.java index b7b0bd06..a673453b 100644 --- a/src/test/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/OrderedEventSelectionStrategyTest.java +++ b/src/test/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/OrderedEventSelectionStrategyTest.java @@ -23,8 +23,11 @@ */ package il.ac.bgu.cs.bp.bpjs.model.eventselection; +import il.ac.bgu.cs.bp.bpjs.TestUtils; +import il.ac.bgu.cs.bp.bpjs.mocks.MockBThreadSyncSnapshot; import il.ac.bgu.cs.bp.bpjs.model.SyncStatement; import il.ac.bgu.cs.bp.bpjs.model.BEvent; +import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot; import java.util.Arrays; import java.util.Collections; import java.util.HashSet; @@ -38,13 +41,10 @@ */ public class OrderedEventSelectionStrategyTest { - public OrderedEventSelectionStrategyTest() { - } - - private static final BEvent evt1 = new BEvent("evt1"); - private static final BEvent evt2 = new BEvent("evt2"); - private static final BEvent evt3 = new BEvent("evt3"); - private static final BEvent evt4 = new BEvent("evt4"); + private static final BEvent EVT_1 = new BEvent("evt1"); + private static final BEvent EVT_2 = new BEvent("evt2"); + private static final BEvent EVT_3 = new BEvent("evt3"); + private static final BEvent EVT_4 = new BEvent("evt4"); /** * Test of selectableEvents method, of class OrderedEventSelectionStrategy. @@ -54,11 +54,12 @@ public void testSelectableEvents_noBlocking() { OrderedEventSelectionStrategy sut = new OrderedEventSelectionStrategy(); - Set stmts = new HashSet<>(); - stmts.add(SyncStatement.make().request(Arrays.asList(evt1, evt2, evt3, evt4))); - stmts.add(SyncStatement.make().request(Arrays.asList(evt2, evt3, evt4))); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS( + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_1, EVT_2, EVT_3, EVT_4))), + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_2, EVT_3, EVT_4))) + ); - assertEquals( new HashSet<>(Arrays.asList(evt1, evt2)), sut.selectableEvents(stmts, Collections.emptyList())); + assertEquals( new HashSet<>(Arrays.asList(EVT_1, EVT_2)), sut.selectableEvents(bpss)); } @Test @@ -66,12 +67,13 @@ public void testSelectableEvents_withBlocking() { OrderedEventSelectionStrategy sut = new OrderedEventSelectionStrategy(); - Set stmts = new HashSet<>(); - stmts.add(SyncStatement.make().request(Arrays.asList(evt1, evt2, evt3, evt4))); - stmts.add(SyncStatement.make().request(Arrays.asList(evt2, evt3, evt4))); - stmts.add(SyncStatement.make().request(Arrays.asList(evt3, evt4)).block(evt1)); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS( + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_1, EVT_2, EVT_3, EVT_4))), + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_2, EVT_3, EVT_4))), + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_3, EVT_4)).block(EVT_1)) + ); - assertEquals( new HashSet<>(Arrays.asList(evt3, evt2)), sut.selectableEvents(stmts, Collections.emptyList())); + assertEquals( new HashSet<>(Arrays.asList(EVT_3, EVT_2)), sut.selectableEvents(bpss)); } } diff --git a/src/test/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PrioritizedBSyncEventSelectionStrategyTest.java b/src/test/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PrioritizedBSyncEventSelectionStrategyTest.java index 0ec58d59..9ab9c0b7 100644 --- a/src/test/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PrioritizedBSyncEventSelectionStrategyTest.java +++ b/src/test/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PrioritizedBSyncEventSelectionStrategyTest.java @@ -1,5 +1,7 @@ package il.ac.bgu.cs.bp.bpjs.model.eventselection; +import il.ac.bgu.cs.bp.bpjs.TestUtils; +import il.ac.bgu.cs.bp.bpjs.mocks.MockBThreadSyncSnapshot; import static org.junit.Assert.assertEquals; import java.util.Arrays; @@ -11,54 +13,53 @@ import il.ac.bgu.cs.bp.bpjs.model.SyncStatement; import il.ac.bgu.cs.bp.bpjs.model.BEvent; +import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot; public class PrioritizedBSyncEventSelectionStrategyTest { - private static final BEvent evt1 = new BEvent("evt1"); - private static final BEvent evt2 = new BEvent("evt2"); - private static final BEvent evt3 = new BEvent("evt3"); - private static final BEvent evt4 = new BEvent("evt4"); + private static final BEvent EVT_1 = new BEvent("evt1"); + private static final BEvent EVT_2 = new BEvent("evt2"); + private static final BEvent EVT_3 = new BEvent("evt3"); + private static final BEvent EVT_4 = new BEvent("evt4"); @Test public void testSelectableEvents_noBlocking() throws InterruptedException { PrioritizedBSyncEventSelectionStrategy sut = new PrioritizedBSyncEventSelectionStrategy(); - Set stmts = new HashSet<>(); - stmts.add(SyncStatement.make().request(Arrays.asList(evt4))); - stmts.add(SyncStatement.make().request(Arrays.asList(evt1)).data(5)); - stmts.add(SyncStatement.make().request(Arrays.asList(evt2)).data(10)); - stmts.add(SyncStatement.make().request(Arrays.asList(evt3)).data(10)); - - assertEquals(new HashSet<>(Arrays.asList(evt2, evt3)), - sut.selectableEvents(stmts, Collections.emptyList())); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS( + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_4))), + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_1)).data(5)), + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_2)).data(10)), + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_3)).data(10)) + ); + assertEquals(new HashSet<>(Arrays.asList(EVT_2, EVT_3)), sut.selectableEvents(bpss)); } @Test public void testSelectableEvents_withBlocking() { PrioritizedBSyncEventSelectionStrategy sut = new PrioritizedBSyncEventSelectionStrategy(); - Set stmts = new HashSet<>(); - stmts.add(SyncStatement.make().request(Arrays.asList(evt4))); - stmts.add(SyncStatement.make().request(Arrays.asList(evt1)).data(5)); - stmts.add(SyncStatement.make().request(Arrays.asList(evt2)).data(1)); - stmts.add(SyncStatement.make().request(Arrays.asList(evt3)).data(10).block(evt2)); - - assertEquals(new HashSet<>(Arrays.asList(evt3)), - sut.selectableEvents(stmts, Collections.emptyList())); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS( + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_4))), + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_1)).data(5)), + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_2)).data(1)), + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_3)).data(10).block(EVT_2)) + ); + assertEquals(new HashSet<>(Arrays.asList(EVT_3)), sut.selectableEvents(bpss)); } @Test public void testSelectableEvents_allBlocked() { PrioritizedBSyncEventSelectionStrategy sut = new PrioritizedBSyncEventSelectionStrategy(); - Set stmts = new HashSet<>(); - stmts.add(SyncStatement.make().request(Arrays.asList(evt4)).block(evt1)); - stmts.add(SyncStatement.make().request(Arrays.asList(evt1)).data(5).block(evt2)); - stmts.add(SyncStatement.make().request(Arrays.asList(evt2)).data(1).block(evt3)); - stmts.add(SyncStatement.make().request(Arrays.asList(evt3)).data(10).block(evt4)); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS( + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_4)).block(EVT_1)), + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_1)).data(5).block(EVT_2)), + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_2)).data(1).block(EVT_3)), + new MockBThreadSyncSnapshot(SyncStatement.make().request(Arrays.asList(EVT_3)).data(10).block(EVT_4)) + ); - assertEquals(Collections.emptySet(), - sut.selectableEvents(stmts, Collections.emptyList())); + assertEquals(Collections.emptySet(), sut.selectableEvents(bpss)); } } diff --git a/src/test/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PrioritizedBThreadsEventSelectionStrategyTest.java b/src/test/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PrioritizedBThreadsEventSelectionStrategyTest.java index dff8a2e7..b324cd18 100644 --- a/src/test/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PrioritizedBThreadsEventSelectionStrategyTest.java +++ b/src/test/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/PrioritizedBThreadsEventSelectionStrategyTest.java @@ -1,16 +1,18 @@ package il.ac.bgu.cs.bp.bpjs.model.eventselection; +import il.ac.bgu.cs.bp.bpjs.TestUtils; +import il.ac.bgu.cs.bp.bpjs.mocks.MockBThreadSyncSnapshot; import static org.junit.Assert.*; import java.util.Arrays; import java.util.Collections; import java.util.HashSet; -import java.util.Set; import org.junit.Test; import il.ac.bgu.cs.bp.bpjs.model.SyncStatement; import il.ac.bgu.cs.bp.bpjs.model.BThreadSyncSnapshot; import il.ac.bgu.cs.bp.bpjs.model.BEvent; +import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot; import org.junit.Before; public class PrioritizedBThreadsEventSelectionStrategyTest { @@ -33,64 +35,61 @@ public void setup() { @Test public void testSelectableEvents_noBlocking() throws InterruptedException { - Set stmts = new HashSet<>(); - stmts.add(SyncStatement.make(bt("1")).request(Arrays.asList(EVT_1))); - stmts.add(SyncStatement.make(bt("2")).request(Arrays.asList(EVT_2))); - stmts.add(SyncStatement.make(bt("3")).request(Arrays.asList(EVT_3))); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS( + new MockBThreadSyncSnapshot("bt1", SyncStatement.make(bt("1")).request(Arrays.asList(EVT_1))), + new MockBThreadSyncSnapshot("bt2", SyncStatement.make(bt("2")).request(Arrays.asList(EVT_2))), + new MockBThreadSyncSnapshot("bt3", SyncStatement.make(bt("3")).request(Arrays.asList(EVT_3))) + ); - assertEquals(new HashSet<>(Arrays.asList(EVT_3)), - sut.selectableEvents(stmts, Collections.emptyList())); + assertEquals(new HashSet<>(Arrays.asList(EVT_3)), sut.selectableEvents(bpss)); } @Test public void testSelectableEvents_noBlocking_double() throws InterruptedException { - Set stmts = new HashSet<>(); - stmts.add(SyncStatement.make(bt("1")).request(Arrays.asList(EVT_1))); - stmts.add(SyncStatement.make(bt("2")).request(Arrays.asList(EVT_2))); - stmts.add(SyncStatement.make(bt("2a")).request(Arrays.asList(EVT_2A))); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS( + new MockBThreadSyncSnapshot("bt1", SyncStatement.make(bt("1")).request(Arrays.asList(EVT_1))), + new MockBThreadSyncSnapshot("bt2", SyncStatement.make(bt("2")).request(Arrays.asList(EVT_2))), + new MockBThreadSyncSnapshot("bt2a", SyncStatement.make(bt("2a")).request(Arrays.asList(EVT_2A))) + ); + assertEquals(new HashSet<>(Arrays.asList(EVT_2, EVT_2A)), - sut.selectableEvents(stmts, Collections.emptyList())); + sut.selectableEvents(bpss)); } @Test public void testSelectableEvents_withBlocking() { - Set stmts = new HashSet<>(); - - stmts.add(SyncStatement.make(bt("1")).request(Arrays.asList(EVT_1))); - stmts.add(SyncStatement.make(bt("2")).request(Arrays.asList(EVT_2)).block(EVT_3)); - stmts.add(SyncStatement.make(bt("3")).request(Arrays.asList(EVT_3))); - + BProgramSyncSnapshot bpss = TestUtils.makeBPSS( + new MockBThreadSyncSnapshot("bt1", SyncStatement.make(bt("1")).request(Arrays.asList(EVT_1))), + new MockBThreadSyncSnapshot("bt2", SyncStatement.make(bt("2")).request(Arrays.asList(EVT_2)).block(EVT_3)), + new MockBThreadSyncSnapshot("bt3", SyncStatement.make(bt("3")).request(Arrays.asList(EVT_3))) + ); assertEquals(new HashSet<>(Arrays.asList(EVT_2)), - sut.selectableEvents(stmts, Collections.emptyList())); + sut.selectableEvents(bpss)); } @Test public void testSelectableEvents_allBlocked() { - Set stmts = new HashSet<>(); - - stmts.add(SyncStatement.make(bt("1")).request(Arrays.asList(EVT_1)).block(EVT_2)); - stmts.add(SyncStatement.make(bt("2")).request(Arrays.asList(EVT_2)).block(EVT_3)); - stmts.add(SyncStatement.make(bt("3")).request(Arrays.asList(EVT_3)).block(EVT_1)); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS( + new MockBThreadSyncSnapshot("bt1", SyncStatement.make(bt("1")).request(Arrays.asList(EVT_1)).block(EVT_2)), + new MockBThreadSyncSnapshot("bt2", SyncStatement.make(bt("2")).request(Arrays.asList(EVT_2)).block(EVT_3)), + new MockBThreadSyncSnapshot("bt3", SyncStatement.make(bt("3")).request(Arrays.asList(EVT_3)).block(EVT_1)) + ); - - assertEquals( Collections.emptySet(), - sut.selectableEvents(stmts, Collections.emptyList())); + assertEquals( Collections.emptySet(), sut.selectableEvents(bpss)); } - @Test public void testSelectableEvents_withBlocking_double() { - Set stmts = new HashSet<>(); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS( + new MockBThreadSyncSnapshot("bt1", SyncStatement.make(bt("1")).request(Arrays.asList(EVT_1))), + new MockBThreadSyncSnapshot("bt2", SyncStatement.make(bt("2")).request(Arrays.asList(EVT_2))), + new MockBThreadSyncSnapshot("bt2a", SyncStatement.make(bt("2a")).request(Arrays.asList(EVT_2A))), + new MockBThreadSyncSnapshot("bt3", SyncStatement.make(bt("3")).block(EVT_2A)) + ); - stmts.add(SyncStatement.make(bt("1")).request(Arrays.asList(EVT_1))); - stmts.add(SyncStatement.make(bt("2")).request(Arrays.asList(EVT_2))); - stmts.add(SyncStatement.make(bt("2a")).request(Arrays.asList(EVT_2A))); - stmts.add(SyncStatement.make(bt("3")).block(EVT_2A)); - - assertEquals(new HashSet<>(Arrays.asList(EVT_2)), - sut.selectableEvents(stmts, Collections.emptyList())); + assertEquals(new HashSet<>(Arrays.asList(EVT_2)), sut.selectableEvents(bpss)); } @Test diff --git a/src/test/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/SimpleEventSelectionStrategyTest.java b/src/test/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/SimpleEventSelectionStrategyTest.java index 8c631496..c599af01 100644 --- a/src/test/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/SimpleEventSelectionStrategyTest.java +++ b/src/test/java/il/ac/bgu/cs/bp/bpjs/model/eventselection/SimpleEventSelectionStrategyTest.java @@ -1,12 +1,15 @@ package il.ac.bgu.cs.bp.bpjs.model.eventselection; +import il.ac.bgu.cs.bp.bpjs.TestUtils; +import il.ac.bgu.cs.bp.bpjs.mocks.MockBThreadSyncSnapshot; import il.ac.bgu.cs.bp.bpjs.model.BEvent; +import il.ac.bgu.cs.bp.bpjs.model.BProgramSyncSnapshot; +import il.ac.bgu.cs.bp.bpjs.model.BThreadSyncSnapshot; import il.ac.bgu.cs.bp.bpjs.model.SyncStatement; import il.ac.bgu.cs.bp.bpjs.model.eventsets.ExplicitEventSet; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; -import static java.util.Collections.emptyList; import static java.util.Collections.emptySet; import static java.util.Collections.singleton; import java.util.HashSet; @@ -38,109 +41,125 @@ public void setUp() { @Test public void testEmptySet() { + BProgramSyncSnapshot bpss = TestUtils.makeBPSS(); assertEquals(Optional.empty(), - sut.select(Collections.emptySet(), Collections.emptyList(), Collections.emptySet()) ); + sut.select(bpss, Collections.emptySet()) ); } @Test public void testNoStatementsWithExternalEvents() { List externals = Arrays.asList(BEvent.named("a"), BEvent.named("b")); EventSelectionStrategy ess = new SimpleEventSelectionStrategy(700); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS(); + bpss.getExternalEvents().addAll(externals); assertEquals(Collections.singleton(externals.get(0)), - ess.selectableEvents(Collections.emptySet(), externals) ); + ess.selectableEvents(bpss) ); } @Test public void testUnanimousCase() { BEvent expected = eventOne; - Set sets = new HashSet<>(Arrays.asList(SyncStatement.make(null).request(eventOne), - SyncStatement.make(null).request(eventOne).waitFor(eventTwo), - SyncStatement.make(null).request(eventOne) - )); - assertEquals(singleton(expected), sut.selectableEvents(sets, Collections.emptyList())); - assertEquals(Optional.of(new EventSelectionResult(expected)), sut.select(sets, Collections.emptyList(),singleton(eventOne))); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS( + new MockBThreadSyncSnapshot(SyncStatement.make(null).request(eventOne)), + new MockBThreadSyncSnapshot(SyncStatement.make(null).request(eventOne).waitFor(eventTwo)), + new MockBThreadSyncSnapshot(SyncStatement.make(null).request(eventOne)) + ); + assertEquals(singleton(expected), sut.selectableEvents(bpss)); + assertEquals(new EventSelectionResult(expected), + sut.select(bpss,singleton(eventOne)).get()); } @Test public void testWithBlockingCase() { BEvent expected = eventOne; - Set sets = new HashSet<>(Arrays.asList(SyncStatement.make(null).request(eventOne), - SyncStatement.make(null).request(eventTwo), - SyncStatement.make(null).block(eventTwo) - )); - assertEquals(singleton(expected), sut.selectableEvents(sets, Collections.emptyList())); - assertEquals(Optional.of(new EventSelectionResult(expected)), - sut.select(sets, Collections.emptyList(), singleton(expected))); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS( + new MockBThreadSyncSnapshot(SyncStatement.make(null).request(eventOne)), + new MockBThreadSyncSnapshot(SyncStatement.make(null).request(eventTwo)), + new MockBThreadSyncSnapshot(SyncStatement.make(null).block(eventTwo)) + ); + assertEquals(singleton(expected), sut.selectableEvents(bpss)); + assertEquals(new EventSelectionResult(expected), + sut.select(bpss, singleton(expected)).get()); } @Test public void testDeadlock() { ExplicitEventSet setOfEvt2 = new ExplicitEventSet(); setOfEvt2.add(eventTwo); - Set sets = new HashSet<>(Arrays.asList(SyncStatement.make(null).request(eventOne), - SyncStatement.make(null).request(setOfEvt2), - SyncStatement.make(null).block(eventTwo), - SyncStatement.make(null).block(eventOne) - )); - assertEquals(emptySet(), sut.selectableEvents(sets, Collections.emptyList())); - assertEquals(Optional.empty(), sut.select(sets, Collections.emptyList(), emptySet())); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS( + new MockBThreadSyncSnapshot(SyncStatement.make(null).request(eventOne)), + new MockBThreadSyncSnapshot(SyncStatement.make(null).request(setOfEvt2)), + new MockBThreadSyncSnapshot(SyncStatement.make(null).block(eventTwo)), + new MockBThreadSyncSnapshot(SyncStatement.make(null).block(eventOne)) + ); + assertEquals(emptySet(), sut.selectableEvents(bpss)); + assertEquals(Optional.empty(), sut.select(bpss, emptySet())); } @Test public void testNoRequests() { - Set sets = new HashSet<>(Arrays.asList(SyncStatement.make(null).waitFor(eventOne), - SyncStatement.make(null).waitFor(eventTwo), - SyncStatement.make(null).block(eventTwo), - SyncStatement.make(null).block(eventOne) - )); - assertEquals(emptySet(), sut.selectableEvents(sets, Collections.emptyList())); - assertEquals(Optional.empty(), sut.select(sets, Collections.emptyList(), emptySet())); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS( + new MockBThreadSyncSnapshot(SyncStatement.make(null).waitFor(eventOne)), + new MockBThreadSyncSnapshot(SyncStatement.make(null).waitFor(eventTwo)), + new MockBThreadSyncSnapshot(SyncStatement.make(null).block(eventTwo)), + new MockBThreadSyncSnapshot(SyncStatement.make(null).block(eventOne)) + ); + assertEquals(emptySet(), sut.selectableEvents(bpss)); + assertEquals(Optional.empty(), sut.select(bpss, emptySet())); } @Test public void testDeadlockWithExternals() { - Set sets = new HashSet<>(Arrays.asList(SyncStatement.make(null).request(eventOne), - SyncStatement.make(null).request(eventTwo), - SyncStatement.make(null).block(eventTwo), - SyncStatement.make(null).block(eventOne) - )); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS( + new MockBThreadSyncSnapshot(SyncStatement.make(null).request(eventOne)), + new MockBThreadSyncSnapshot(SyncStatement.make(null).request(eventTwo)), + new MockBThreadSyncSnapshot(SyncStatement.make(null).block(eventTwo)), + new MockBThreadSyncSnapshot(SyncStatement.make(null).block(eventOne)) + ); List externals = Arrays.asList(eventOne, eventTri, eventTri, eventTwo); - assertEquals( singleton(eventTri), sut.selectableEvents(sets, externals)); - assertEquals( Optional.of(new EventSelectionResult(eventTri, singleton(1))), - sut.select(sets, externals, singleton(eventTri))); + bpss.getExternalEvents().addAll(externals); + assertEquals( singleton(eventTri), sut.selectableEvents(bpss)); + assertEquals( new EventSelectionResult(eventTri, singleton(1)), + sut.select(bpss, singleton(eventTri)).get()); } @Test public void testNoInternalRequests() { - Set sets = new HashSet<>(Arrays.asList(SyncStatement.make(null).waitFor(eventOne), - SyncStatement.make(null).waitFor(eventTri), - SyncStatement.make(null).waitFor(eventTwo) - )); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS( + new MockBThreadSyncSnapshot(SyncStatement.make(null).waitFor(eventOne)), + new MockBThreadSyncSnapshot(SyncStatement.make(null).waitFor(eventTri)), + new MockBThreadSyncSnapshot(SyncStatement.make(null).waitFor(eventTwo)) + ); List externals = Arrays.asList(eventOne, eventTwo, eventTri, eventTwo); + bpss.getExternalEvents().addAll(externals); - assertEquals( singleton(eventOne), sut.selectableEvents(sets, externals)); - assertEquals(Optional.of( new EventSelectionResult(eventOne, singleton(0))), - sut.select(sets, externals, singleton(eventOne))); + assertEquals( singleton(eventOne), sut.selectableEvents(bpss)); + assertEquals( new EventSelectionResult(eventOne, singleton(0)), + sut.select(bpss, singleton(eventOne)).get()); } @Test public void testSeed() { Set events = IntStream.range(0, 1000).mapToObj( i -> BEvent.named("evt"+i) ).collect( toSet() ); - Set stmts = events.stream().map(e -> SyncStatement.make().request(e)).collect(toSet()); + Set btssSet = new HashSet<>(); + events.stream().map(e -> SyncStatement.make().request(e)) + .map( s->new MockBThreadSyncSnapshot(s)) + .forEach(btssSet::add); + BProgramSyncSnapshot bpss = TestUtils.makeBPSS(btssSet); // See what sut does List selectedBySut = new ArrayList<>(1000); for ( int i=0; i<1000; i++ ) { - selectedBySut.add( sut.select(stmts, emptyList(), events).get().getEvent() ); + selectedBySut.add( sut.select(bpss, events).get().getEvent() ); } // replicate with a strategy with the same seed EventSelectionStrategy sameSeedEss = new SimpleEventSelectionStrategy(sut.getSeed()); List selectedBySameSeed = new ArrayList<>(1000); for ( int i=0; i<1000; i++ ) { - selectedBySameSeed.add( sameSeedEss.select(stmts, emptyList(), events).get().getEvent() ); + selectedBySameSeed.add( sameSeedEss.select(bpss, events).get().getEvent() ); } assertEquals( selectedBySut, selectedBySameSeed );