LatchStateMachineListener.java

/*
 * Copyright 2015 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.statemachine.test.support;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

import org.springframework.messaging.Message;
import org.springframework.statemachine.StateMachine;
import org.springframework.statemachine.listener.StateMachineListener;
import org.springframework.statemachine.listener.StateMachineListenerAdapter;
import org.springframework.statemachine.state.State;
import org.springframework.statemachine.transition.Transition;

/**
 * A {@link StateMachineListener} which is used during the tests
 * to assert correct count of listener callbacks.
 *
 * @author Janne Valkealahti
 *
 * @param <S> the type of state
 * @param <E> the type of event
 */
public class LatchStateMachineListener<S, E> extends StateMachineListenerAdapter<S, E> {

	private final Object lock = new Object();

	private volatile CountDownLatch stateChangedLatch = new CountDownLatch(1);
	private volatile CountDownLatch stateEnteredLatch = new CountDownLatch(1);
	private volatile CountDownLatch stateExitedLatch = new CountDownLatch(1);
	private volatile CountDownLatch eventNotAcceptedLatch = new CountDownLatch(1);
	private volatile CountDownLatch transitionLatch = new CountDownLatch(1);
	private volatile CountDownLatch transitionStartedLatch = new CountDownLatch(1);
	private volatile CountDownLatch transitionEndedLatch = new CountDownLatch(1);
	private volatile CountDownLatch stateMachineStartedLatch = new CountDownLatch(1);
	private volatile CountDownLatch stateMachineStoppedLatch = new CountDownLatch(1);
	private volatile CountDownLatch extendedStateChangedLatch = new CountDownLatch(1);

	private final List<StateChangedWrapper<S, E>> stateChanged = new ArrayList<StateChangedWrapper<S, E>>();
	private final List<State<S, E>> stateEntered = new ArrayList<State<S, E>>();
	private final List<State<S, E>> stateExited = new ArrayList<State<S, E>>();
	private final List<Message<E>> eventNotAccepted = new ArrayList<Message<E>>();
	private final List<Transition<S, E>> transition = new ArrayList<Transition<S, E>>();
	private final List<Transition<S, E>> transitionStarted = new ArrayList<Transition<S, E>>();
	private final List<Transition<S, E>> transitionEnded = new ArrayList<Transition<S, E>>();
	private final List<StateMachine<S, E>> stateMachineStarted = new ArrayList<StateMachine<S, E>>();
	private final List<StateMachine<S, E>> stateMachineStopped = new ArrayList<StateMachine<S, E>>();
	private final List<ExtendedStateChangedWrapper> extendedStateChanged = new ArrayList<ExtendedStateChangedWrapper>();

	@Override
	public void stateChanged(State<S, E> from, State<S, E> to) {
		synchronized (lock) {
			this.stateChanged.add(new StateChangedWrapper<>(from, to));
			this.stateChangedLatch.countDown();
		}
	}

	@Override
	public void stateEntered(State<S, E> state) {
		synchronized (lock) {
			this.stateEntered.add(state);
			this.stateEnteredLatch.countDown();
		}
	}

	@Override
	public void stateExited(State<S, E> state) {
		synchronized (lock) {
			this.stateExited.add(state);
			this.stateExitedLatch.countDown();
		}
	}

	@Override
	public void eventNotAccepted(Message<E> event) {
		synchronized (lock) {
			this.eventNotAccepted.add(event);
			this.eventNotAcceptedLatch.countDown();
		}
	}

	@Override
	public void transition(Transition<S, E> transition) {
		synchronized (lock) {
			this.transition.add(transition);
			this.transitionLatch.countDown();
		}
	}

	@Override
	public void transitionStarted(Transition<S, E> transition) {
		synchronized (lock) {
			this.transitionStarted.add(transition);
			this.transitionStartedLatch.countDown();
		}
	}

	@Override
	public void transitionEnded(Transition<S, E> transition) {
		synchronized (lock) {
			this.transitionEnded.add(transition);
			this.transitionEndedLatch.countDown();
		}
	}

	@Override
	public void stateMachineStarted(StateMachine<S, E> stateMachine) {
		synchronized (lock) {
			this.stateMachineStarted.add(stateMachine);
			this.stateMachineStartedLatch.countDown();
		}
	}

	@Override
	public void stateMachineStopped(StateMachine<S, E> stateMachine) {
		synchronized (lock) {
			this.stateMachineStopped.add(stateMachine);
			this.stateMachineStoppedLatch.countDown();
		}
	}

	@Override
	public void extendedStateChanged(Object key, Object value) {
		synchronized (lock) {
			this.extendedStateChanged.add(new ExtendedStateChangedWrapper(key, value));
			this.extendedStateChangedLatch.countDown();
		}
	}

	public void reset(int stateChangedCount, int stateEnteredCount, int stateExitedCount, int eventNotAcceptedCount,
			int transitionCount, int transitionStartedCount, int transitionEndedCount, int stateMachineStartedCount,
			int stateMachineStoppedCount, int extendedStateChangedCount) {
		synchronized (lock) {
			this.stateChangedLatch = new CountDownLatch(stateChangedCount);
			this.stateEnteredLatch = new CountDownLatch(stateEnteredCount);
			this.stateExitedLatch = new CountDownLatch(stateExitedCount);
			this.eventNotAcceptedLatch = new CountDownLatch(eventNotAcceptedCount);
			this.transitionLatch = new CountDownLatch(transitionCount);
			this.transitionStartedLatch = new CountDownLatch(transitionStartedCount);
			this.transitionEndedLatch = new CountDownLatch(transitionEndedCount);
			this.stateMachineStartedLatch = new CountDownLatch(stateMachineStartedCount);
			this.stateMachineStoppedLatch = new CountDownLatch(stateMachineStoppedCount);
			this.extendedStateChangedLatch = new CountDownLatch(extendedStateChangedCount);
			this.stateChanged.clear();
			this.stateEntered.clear();
			this.stateExited.clear();
			this.eventNotAccepted.clear();
			this.transition.clear();
			this.transitionStarted.clear();
			this.transitionEnded.clear();
			this.stateMachineStarted.clear();
			this.stateMachineStopped.clear();
			this.extendedStateChanged.clear();
		}
	}

	public CountDownLatch getStateChangedLatch() {
		return stateChangedLatch;
	}

	public CountDownLatch getStateEnteredLatch() {
		return stateEnteredLatch;
	}

	public CountDownLatch getStateExitedLatch() {
		return stateExitedLatch;
	}

	public CountDownLatch getEventNotAcceptedLatch() {
		return eventNotAcceptedLatch;
	}

	public CountDownLatch getTransitionLatch() {
		return transitionLatch;
	}

	public CountDownLatch getTransitionStartedLatch() {
		return transitionStartedLatch;
	}

	public CountDownLatch getTransitionEndedLatch() {
		return transitionEndedLatch;
	}

	public CountDownLatch getStateMachineStartedLatch() {
		return stateMachineStartedLatch;
	}

	public CountDownLatch getStateMachineStoppedLatch() {
		return stateMachineStoppedLatch;
	}

	public CountDownLatch getExtendedStateChangedLatch() {
		return extendedStateChangedLatch;
	}

	public List<StateChangedWrapper<S, E>> getStateChanged() {
		return stateChanged;
	}

	public List<State<S, E>> getStateEntered() {
		return stateEntered;
	}

	public List<State<S, E>> getStateExited() {
		return stateExited;
	}

	public List<Message<E>> getEventNotAccepted() {
		return eventNotAccepted;
	}

	public List<Transition<S, E>> getTransition() {
		return transition;
	}

	public List<Transition<S, E>> getTransitionStarted() {
		return transitionStarted;
	}

	public List<Transition<S, E>> getTransitionEnded() {
		return transitionEnded;
	}

	public List<StateMachine<S, E>> getStateMachineStarted() {
		return stateMachineStarted;
	}

	public List<StateMachine<S, E>> getStateMachineStopped() {
		return stateMachineStopped;
	}

	public List<ExtendedStateChangedWrapper> getExtendedStateChanged() {
		return extendedStateChanged;
	}

	public static class StateChangedWrapper<S, E> {
		final State<S, E> from;
		final State<S, E> to;

		public StateChangedWrapper(State<S, E> from, State<S, E> to) {
			this.from = from;
			this.to = to;
		}

	}

	public static class ExtendedStateChangedWrapper {
		final Object key;
		final Object value;

		public ExtendedStateChangedWrapper(Object key, Object value) {
			this.key = key;
			this.value = value;
		}

	}

}