package org.xvsm.core.aspect;
   
   import static org.junit.Assert.assertFalse;
   import static org.junit.Assert.assertNotNull;
   import static org.junit.Assert.assertTrue;
   
   import java.net.URI;
   import java.util.ArrayList;
   import java.util.Collection;
  import java.util.List;
  import java.util.Properties;
  
  import org.junit.Before;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.junit.runners.Parameterized;
  import org.junit.runners.Parameterized.Parameters;
  import org.xvsm.TestParameterConfiguration;
  import org.xvsm.coordinators.FifoCoordinator;
  import org.xvsm.coordinators.GenericKeyCoordinator;
  import org.xvsm.coordinators.LindaCoordinator;
  import org.xvsm.core.AtomicEntry;
  import org.xvsm.core.Capi;
  import org.xvsm.core.ContainerRef;
  import org.xvsm.core.Entry;
  import org.xvsm.core.Tuple;
  import org.xvsm.core.notifications.Operation;
  import org.xvsm.interfaces.ICapi;
  import org.xvsm.interfaces.ICoordinator;
  import org.xvsm.interfaces.NotificationListener;
  import org.xvsm.interfaces.container.IContainer;
  import org.xvsm.internal.ContainerManager;
  import org.xvsm.internal.exceptions.AspectNotOkException;
  import org.xvsm.internal.exceptions.AspectRescheduleException;
  import org.xvsm.internal.exceptions.AspectSkipException;
  import org.xvsm.internal.exceptions.FatalException;
  import org.xvsm.internal.exceptions.InvalidContainerException;
  import org.xvsm.internal.exceptions.XCoreException;
  import org.xvsm.selectors.FifoSelector;
  import org.xvsm.selectors.GenericKeySelector;
  import org.xvsm.selectors.KeySelector;
  import org.xvsm.selectors.LindaSelector;
  import org.xvsm.selectors.Selector;
  import org.xvsm.transactions.Transaction;
  
  @RunWith(Parameterized.class)
  public class CustomNotificationTest implements NotificationListener {
  
  	/***
  	 * The URI of the core instance used for testing.
  	 */
  	private static URI defaultURI;
  
  	/***
  	 * The ICapi instance used by this test case.
  	 */
  	private ICapi capi;
  
  	/***
  	 * This field is set to true when the notification fires and is used to
  	 * check if the notification is executed as expected.
  	 */
  	private Boolean fired = false;
  
  	/***
  	 * The aspect used for handling the notification. This implementation only
  	 * support notifications on write.
  	 * 
  	 * @author Christian Schreiber
  	 * 
  	 */
  	public static class WriteNotification extends LocalAspect {
  		/***
  		 * Auto generated serial version uid.
  		 */
  		private static final long serialVersionUID = -6750217343530283108L;
  		/***
  		 * The Capi instance used by the aspect.
  		 */
  		private ICapi capi;
  
  		/***
  		 * The container on which the notification is registered.
  		 */
  		private ContainerRef cref;
  
  		/***
  		 * The notification container which is used to collect the
  		 * notifications.
  		 */
  		private ContainerRef ncref;
  
  		/***
  		 * Default constructor.
  		 */
  		public WriteNotification() {
  			try {
  				capi = new Capi();
  			} catch (Exception e) {
 				throw new FatalException(e);
 			}
 		}
 
 		public WriteNotification(ContainerRef cref, ContainerRef ncref) {
 			this();
 			super.properties.put("cref", new AtomicEntry<URI>(cref.asURI()));
 			super.properties.put("ncref", new AtomicEntry<URI>(ncref.asURI()));
 
 			this.cref = cref;
 			this.ncref = ncref;
 		}
 
 		@Override
 		public void finalize() throws Throwable {
 			super.finalize();
 			// remove the notification container.
 			if (this.ncref != null) {
 				ContainerManager.getInstance().deleteContainer(null, ncref);
 			}
 		}
 
 		@Override
 		public void postWrite(ContainerRef cref, Transaction tx,
 				List<Entry> entries, Properties contextProperties)
 				throws AspectNotOkException, AspectRescheduleException,
 				AspectSkipException {
 			try {
 				for (Entry entry : entries) {
 					// If no copy is used for writing it might happen that
 					// transaction logs are messed up when the container is
 					// within the same core instance.
 					Entry e = entry.getFlatCopy();
 					// use the same selectors as used for the "original entry".
 					// Please note that it might cause an exception when "ncref"
 					// does not provide the coordinators.
 					e.setSelectors(entry.getSelectors());
 					this.capi.write(ncref, 0, tx, e);
 				}
 			} catch (XCoreException e) {
 				throw new FatalException(e);
 			}
 		}
 
 		// the following two methods are required when the aspect is
 		// transaported using the XML protocol.
 		@Override
 		public void setProperties(Properties props) {
 			this.cref = new ContainerRef((URI) ((AtomicEntry<?>) props
 					.get("cref")).getValue());
 			this.ncref = new ContainerRef((URI) ((AtomicEntry<?>) props
 					.get("ncref")).getValue());
 			this.properties = props;
 		}
 
 		@Override
 		public Properties getProperties() {
 			return this.properties;
 		}
 	}
 
 	/***
 	 * Constructor.
 	 * 
 	 * @param defaultURI
 	 *            the URI of the space instance used for testing.
 	 * @throws Exception
 	 */
 	public CustomNotificationTest(URI defaultURI) throws Exception {
 		CustomNotificationTest.defaultURI = defaultURI;
 		this.capi = new Capi();
 	}
 
 	@Parameters
 	public static Collection<?> regExValues() throws Exception {
 		return TestParameterConfiguration.getURIs();
 	}
 
 	@Before
 	public void setUp() throws Exception {
 		this.fired = false;
 	}
 
 	/***
 	 * Creates a new notification.
 	 * 
 	 * @param cref
 	 *            the ContainerRef on which the notification shall be
 	 *            registered.
 	 * @param selectors
 	 *            the selectors which have to match in order to fire the
 	 *            notification.
 	 * @return the URI of the notification aspect (required to unregister the
 	 *         notification).
 	 */
 	private URI createNotification(ContainerRef cref,
 			final NotificationListener listener, final Selector... selectors)
 			throws Exception {
 		// read the coordinators from the meta container and create a new
 		// container which has the same coordinators (if possible, see below).
 
 		// the constructor Container(String s); assumes that s is only the id of
 		// the container without the rest of the URI. Therefore we have to use
 		// Contaner(URI uri) here.
 		ContainerRef metaCref = new ContainerRef(new URI(cref.asURI()
 				.toASCIIString()
 				+ "/meta"));
 		Entry[] result = capi.read(metaCref, 0, null, new KeySelector<String>(
 				"system", "coordinators"));
 		Tuple t = (Tuple) result[0];
 
 		List<ICoordinator> coordinators = new ArrayList<ICoordinator>();
 		for (Entry e : t) {
 			AtomicEntry<?> ae = (AtomicEntry<?>) e;
 			String coordinatorName = (String) ae.getValue();
 
 			if (coordinatorName.equals("LabelCoordinator")
 					|| coordinatorName.equals("KeyCoordinator")) {
 				// TODO implement the functionality to the properties from
 				// coordinators.
 				throw new FatalException("Cannot create a notification for \""
 						+ coordinatorName + "\" because this coordinator "
 						+ "needs extra properties.");
 			}
 			Class<?> clazz = Class.forName("org.xvsm.coordinators."
 					+ coordinatorName);
 			ICoordinator coordinator = (ICoordinator) clazz.newInstance();
 			coordinators.add(coordinator);
 		}
 		// always add a linda coordinator in order to enable template matching.
 		coordinators.add(new LindaCoordinator());
 
 		// If you need a KeyCoordintaor or LabelCoordinator you can add it here
 		// (do not forget the KeyType!).
 
 		// create the notification container. This container will contain all
 		// notification events.
 		final ContainerRef ncref = this.capi.createContainer(null, null, null,
 				IContainer.INFINITE_SIZE, coordinators
 						.toArray(new ICoordinator[0]));
 		// add the notification aspect to the container.
 		URI aspectURI = this.capi.addAspect(cref, java.util.Arrays
 				.asList(new LocalIPoint[] { LocalIPoint.PostWrite }),
 				new WriteNotification(cref, ncref));
 		// create a thread which waits for new (matching) entries.
 		Thread thread = new Thread() {
 			public void run() {
 				while (true) {
 					try {
 						Entry[] entries = capi.take(ncref,
 								ICapi.INFINITE_TIMEOUT, null, selectors);
 						// in this case the operation field is not used.
 						listener.handleNotification(null, entries);
 					} catch (Exception e) {
 						// ignore
 					}
 				}
 			}
 		};
 		thread.start();
 		return aspectURI;
 	}
 
 	@Test
 	public void testNotificationWithSelector() throws Exception {
 		ContainerRef cref = this.capi.createContainer(null, defaultURI, null,
 				IContainer.INFINITE_SIZE, new FifoCoordinator(),
 				new LindaCoordinator());
 		URI notifURI = this.createNotification(cref, this, new FifoSelector());
 		assertNotNull(notifURI);
 
 		// write some entry to bring the notification to fire.
 		this.capi.write(cref, 0, null, new AtomicEntry<String>(
 				"Hello Notification", String.class, new FifoSelector()));
 
 		synchronized (this.fired) {
 			this.fired.wait(10000);
 			assertTrue(this.fired);
 		}
 
 		// clean up
 		this.capi.destroyContainer(null, cref);
 	}
 
 	@Test
 	public void testNotificationWithLindaSelector() throws Exception {
 		ContainerRef cref = this.capi.createContainer(null, defaultURI, null,
 				IContainer.INFINITE_SIZE, new FifoCoordinator());
 		URI notifURI = this.createNotification(cref, this, new LindaSelector(
 				new Tuple(new AtomicEntry<String>(String.class))));
 		assertNotNull(notifURI);
 
 		// write some entry to bring the notification to fire.
 		this.capi.write(cref, 0, null, new Tuple(new AtomicEntry<String>(
 				"Hello Notification")));
 
 		synchronized (this.fired) {
 			this.fired.wait(10000);
 			assertTrue(this.fired);
 			this.fired = false;
 		}
 
 		// try again with an entry that does not match the template
 		this.capi.write(cref, 0, null, new Tuple(new AtomicEntry<String>(
 				"I do not match the template"), new AtomicEntry<Integer>(666)));
 		synchronized (this.fired) {
 			this.fired.wait(10000);
 			assertFalse(this.fired);
 		}
 		// clean up
 		this.capi.destroyContainer(null, cref);
 	}
 
 	@Test
 	public void testNotificationWithGenericKey() throws Exception {
 		// Please note that this does not work with the KeyCoordinator because
 		// you have to provide the KeyType during initialization.
 		ContainerRef cref = this.capi.createContainer(null, defaultURI, null,
 				IContainer.INFINITE_SIZE, new GenericKeyCoordinator());
 		URI notifURI = this.createNotification(cref, this,
 				new GenericKeySelector<String>("test", "10"));
 		assertNotNull(notifURI);
 
 		// write some entry to bring the notification to fire.
 		this.capi.write(cref, 0, null, new AtomicEntry<Integer>(100,
 				Integer.class, new GenericKeySelector<String>("test", "10")));
 		// Please note that this may cause a problem: when somebody already
 		// wrote an entry on this position (and did not take this entry from the
 		// notification container) the position in the notification container is
 		// not free an the write operation in the aspect will cause an
 		// exception. It would be possible to use "shift" instead of "write" in
 		// the aspect but then it is possible that the user misses a
 		// notification.
 
 		synchronized (this.fired) {
 			this.fired.wait(10000);
 			assertTrue(this.fired);
 			this.fired = false;
 		}
 
 		// test again with key that does not match
 		this.capi.write(cref, 0, null, new AtomicEntry<Integer>(100,
 				Integer.class, new GenericKeySelector<String>("test", "1")));
 
 		synchronized (this.fired) {
 			this.fired.wait(10000);
 			assertFalse(this.fired);
 			this.fired = false;
 		}
 
 		// clean up
 		this.capi.destroyContainer(null, cref);
 	}
 
 	/***
 	 * The callback method of the notification.
 	 */
 	public void handleNotification(Operation operation, Entry... entries) {
 		System.out.println("Notification fired :)");
 		System.out
 				.println(operation + " " + java.util.Arrays.toString(entries));
 		synchronized (this.fired) {
 			this.fired.notify();
 			this.fired = true;
 		}
 	}
 }