net.sf.javagimmicks.event.testing.EventCollector Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of gimmicks Show documentation
Utility classes, APIs and tools for Java
There is a newer version: 0.99-alpha1
package net.sf.javagimmicks.event.testing;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;

import java.util.LinkedList;
import java.util.Queue;

import net.sf.javagimmicks.event.Event;
import net.sf.javagimmicks.event.EventListener;
import net.sf.javagimmicks.event.Observable;

/**
 * A generic {@link EventListener} usable for testing that remembers all
 * observed {@link Event}s in a {@link Queue} and provides easy assertions calls
 * against them.
 * 
 * @param 
 *           the type of {@link Event} that is observed
 */
public class EventCollector> implements EventListener
{
   private final Class _eventClass;
   private final Observable _source;

   private Queue _events = new LinkedList();

   /**
    * Creates a new instance for the given {@link Event} class and source
    * {@link Observable}.
    * 
    * @param eventClass
    *           the {@link Class} of the events to evaluate
    * @param source
    *           the source {@link Observable} that creates the {@link Event}s
    */
   public EventCollector(final Class eventClass, final Observable source)
   {
      _eventClass = eventClass;
      _source = source;
   }

   @Override
   public void eventOccured(final Evt event)
   {
      _events.offer(event);
   }

   /**
    * Makes an assertion to the next {@link Event} in the internal {@link Queue}
    * and removes from there. The following assertions are automatically done -
    * more can be specified with a given {@link Validator}.
    * 
    * There is an {@link Event} in the internal {@link Queue}
    * The {@link Event} is an instance of the type provided within the
    * constructor (see {@link #EventCollector(Class, Observable)})
    * The {@link Event#getSource()} call returns the same {@link Observable}
    * that was given within the constructor (see
    * {@link #EventCollector(Class, Observable)})
    * 
    * 
    * @param customValidator
    *           a custom {@link Validator} that can be used to specify
    *           {@link Event}-specific validation logic
    * @see Validator
    */
   public void assertEventOccured(final Validator customValidator)
   {
      assertFalse("No (more) events in queue!", _events.isEmpty());
      final Evt event = _events.poll();

      assertTrue("Event has wrong type", _eventClass.isAssignableFrom(event.getClass()));
      assertSame("Event has wrong source", _source, event.getSource());

      if (customValidator != null)
      {
         customValidator.validate(event);
      }
   }

   /**
    * Convenience method to {@link #assertEventOccured(Validator)} but without a
    * custom {@link Validator}.
    * 
    * @see #assertEventOccured(Validator)
    */
   public void assertEventOccured()
   {
      assertEventOccured(null);
   }

   /**
    * Clear the internal {@link Event} {@link Queue}.
    */
   public void clear()
   {
      _events.clear();
   }

   /**
    * Makes an assertion that the internal {@link Event} {@link Queue} is empty.
    */
   public void assertEmpty()
   {
      assertTrue("Event queue is not empty!", _events.isEmpty());
   }

   /**
    * A generic validator that allows specification of {@link Event}-specific
    * assertions.
    * 
    * @param 
    *           the type {@link Event}s that should be validated
    */
   public static interface Validator>
   {
      /**
       * Make any assertions against the given {@link Event}.
       * 
       * @param event
       *           the {@link Event} to validate by making some assertions
       *           against it
       */
      void validate(Evt event);
   }
}