NIODatashareTest.java

/******************************************************************************
 * Copyright (c) 2009 Remy Chi Jian Suen and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Remy Chi Jian Suen - initial API and implementation
 ******************************************************************************/
package org.eclipse.ecf.tests.provider.datashare.nio;

import java.net.InetSocketAddress;

import junit.framework.TestCase;

import org.eclipse.ecf.core.IContainer;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.core.identity.IDFactory;
import org.eclipse.ecf.core.util.ECFException;
import org.eclipse.ecf.datashare.IChannel;
import org.eclipse.ecf.datashare.IChannelContainerAdapter;
import org.eclipse.ecf.datashare.IChannelListener;
import org.eclipse.ecf.datashare.events.IChannelConnectEvent;
import org.eclipse.ecf.datashare.events.IChannelDisconnectEvent;
import org.eclipse.ecf.datashare.events.IChannelEvent;
import org.eclipse.ecf.datashare.events.IChannelMessageEvent;

public class NIODatashareTest extends TestCase {

	private static final String LOCALHOST = "127.0.0.1"; //$NON-NLS-1$
	// private static final String LOCALHOST = "localhost"; //$NON-NLS-1$
	// private static final String LOCALHOST = "0.0.0.0"; //$NON-NLS-1$

	private static final String CHANNEL_NAME = "channel"; //$NON-NLS-1$

	private Object waitObject = new Object();

	private Exception exception;

	private IContainer containerA = new ContainerImpl();
	private IContainer containerB = new ContainerImpl();

	private ConcreteNIODatashareContainer channelContainerA;
	private ConcreteNIODatashareContainer channelContainerB;

	private ConcreteNIOChannel channelA;
	private ConcreteNIOChannel channelB;

	private static void assertEquals(byte[] expected, byte[] actual) {
		// don't use Arrays.equals(byte[], byte[]) to get more accurate failure
		// information
		assertNotNull(expected);
		assertNotNull(actual);

		assertEquals(expected.length, actual.length);

		for (int i = 0; i < expected.length; i++) {
			assertEquals(expected[i], actual[i]);
		}
	}

	private static ConcreteNIOChannel createChannel(
			IChannelContainerAdapter channelContainer) throws ECFException {
		return createChannel(channelContainer, null);
	}

	private static ConcreteNIOChannel createChannel(
			IChannelContainerAdapter channelContainer, IChannelListener listener)
			throws ECFException {
		return (ConcreteNIOChannel) channelContainer.createChannel(IDFactory
				.getDefault().createStringID(CHANNEL_NAME), listener, null);
	}

	protected void setUp() throws Exception {
		super.setUp();

		channelContainerA = new ConcreteNIODatashareContainer(containerA);
		channelContainerB = new ConcreteNIODatashareContainer(containerB);

		exception = null;
	}

	protected void tearDown() throws Exception {
		containerA.disconnect();
		containerB.disconnect();

		channelContainerA = null;
		channelContainerB = null;

		channelA = null;
		channelB = null;

		// just to make sure we don't have any pending threads
		synchronized (waitObject) {
			waitObject.notifyAll();
		}

		super.tearDown();
	}

	private void waitForCompletion(long timeout) throws Exception {
		synchronized (waitObject) {
			waitObject.wait(timeout);
		}

		if (exception != null) {
			throw exception;
		}
	}

	private void send(IChannel channel, ID receiver, byte[] data) {
		try {
			channel.sendMessage(receiver, data);
		} catch (ECFException e) {
			exception = e;

			synchronized (waitObject) {
				waitObject.notify();
			}
		}
	}

	public void testChannelConnectEvent() throws Exception {
		final ID[] eventIds = new ID[2];

		channelA = createChannel(channelContainerA, new IChannelListener() {
			public void handleChannelEvent(IChannelEvent e) {
				if (e instanceof IChannelConnectEvent) {
					IChannelConnectEvent event = (IChannelConnectEvent) e;
					eventIds[0] = event.getChannelID();
					eventIds[1] = event.getTargetID();
				}
			}
		});

		containerA.connect(null, null);

		assertEquals(channelA.getID(), eventIds[0]);
		assertEquals(containerA.getConnectedID(), eventIds[1]);
	}

	/**
	 * Test that while the container fires events, the datashare implementation
	 * is ignoring them successfully as it does not have a listener and is not
	 * throwing runtime exceptions.
	 */
	public void testChannelConnectEventWithoutListeners() throws Exception {
		channelA = createChannel(channelContainerA);
		containerA.connect(null, null);
	}

	public void testChannelDisconnectEvent() throws Exception {
		final ID[] eventIds = new ID[2];

		channelA = createChannel(channelContainerA, new IChannelListener() {
			public void handleChannelEvent(IChannelEvent e) {
				if (e instanceof IChannelDisconnectEvent) {
					IChannelDisconnectEvent event = (IChannelDisconnectEvent) e;
					eventIds[0] = event.getChannelID();
					eventIds[1] = event.getTargetID();
				}
			}
		});

		containerA.disconnect();

		assertEquals(channelA.getID(), eventIds[0]);
		// technically, getConnectedID() should return null when a container has
		// disconnected, but anyway...
		assertEquals(containerA.getConnectedID(), eventIds[1]);
	}

	/**
	 * Test that while the container fires events, the datashare implementation
	 * is ignoring them successfully as it does not have a listener and is not
	 * throwing runtime exceptions.
	 */
	public void testChannelDisconnectEventWithoutListeners() throws Exception {
		channelA = createChannel(channelContainerA, null);
		containerA.disconnect();
	}

	public void testOneWaySend() throws Exception {
		final byte[][] actual = new byte[1][];

		channelA = createChannel(channelContainerA);

		int targetPort = channelA.getPort();

		channelB = createChannel(channelContainerB, new IChannelListener() {
			public void handleChannelEvent(IChannelEvent event) {
				if (event instanceof IChannelMessageEvent) {
					actual[0] = ((IChannelMessageEvent) event).getData();

					synchronized (waitObject) {
						waitObject.notify();
					}
				}
			}
		});

		byte[] expected = { 1, 2, 3 };

		channelA.sendMessage(containerB.getConnectedID(), expected);

		channelContainerB.enqueue(new InetSocketAddress(LOCALHOST, targetPort));

		waitForCompletion(5000);

		assertEquals(expected, actual[0]);
	}

	public void testOneWaySend16k() throws Exception {
		final byte[][] actual = new byte[1][];

		channelA = createChannel(channelContainerA);

		int targetPort = channelA.getPort();

		channelB = createChannel(channelContainerB, new IChannelListener() {
			public void handleChannelEvent(IChannelEvent event) {
				if (event instanceof IChannelMessageEvent) {
					actual[0] = ((IChannelMessageEvent) event).getData();

					synchronized (waitObject) {
						waitObject.notify();
					}
				}
			}
		});

		byte[] expected = new byte[16384];
		for (int i = 0; i < expected.length; i++) {
			expected[i] = (byte) (i % 128);
		}

		channelA.sendMessage(containerB.getConnectedID(), expected);

		channelContainerB.enqueue(new InetSocketAddress(LOCALHOST, targetPort));

		waitForCompletion(10000);

		assertEquals(expected, actual[0]);
	}

	public void testSendAndReply() throws Exception {
		final byte[] expected1 = { 1, 2, 3 };
		final byte[] expected2 = { 4, 5, 6 };

		final byte[][] actual = new byte[2][];

		channelA = createChannel(channelContainerA, new IChannelListener() {
			public void handleChannelEvent(IChannelEvent event) {
				if (event instanceof IChannelMessageEvent) {
					actual[1] = ((IChannelMessageEvent) event).getData();

					synchronized (waitObject) {
						waitObject.notify();
					}
				}
			}
		});

		int targetPort = channelA.getPort();

		channelB = createChannel(channelContainerB, new IChannelListener() {
			public void handleChannelEvent(IChannelEvent event) {
				if (event instanceof IChannelMessageEvent) {
					actual[0] = ((IChannelMessageEvent) event).getData();

					send(channelB, containerA.getConnectedID(), expected2);
				}
			}
		});

		channelA.sendMessage(containerB.getConnectedID(), expected1);

		channelContainerB.enqueue(new InetSocketAddress(LOCALHOST, targetPort));

		waitForCompletion(5000);

		assertEquals(expected1, actual[0]);
		assertEquals(expected2, actual[1]);
	}
}