tests/org.eclipse.emf.ecp.view.validation.test/src/org/eclipse/emf/ecp/view/validation/test/ConcurrentLinkedSetQueue_Test.java

/*******************************************************************************
 * Copyright (c) 2011-2019 EclipseSource Muenchen GmbH and others.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 * nicole.behlen - initial API and implementation
 ******************************************************************************/
package org.eclipse.emf.ecp.view.validation.test;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;

import org.eclipse.emf.ecp.view.internal.validation.ConcurrentLinkedSetQueue;
import org.junit.Test;

/**
 * JUnit to test the uniqueness functionality of {@link ConcurrentLinkedSetQueue}.
 *
 * @author nicole.behlen
 */
public class ConcurrentLinkedSetQueue_Test {

	@Test(expected = NullPointerException.class)
	public void offer_Null() {
		/* setup */
		final ConcurrentLinkedSetQueue<Integer> queue = new ConcurrentLinkedSetQueue<>();
		/* act */
		queue.offer(null);
		/* assert */
		// null pointer exception
	}

	@Test
	public void offer_NoRepeat() {
		/* setup */
		final ConcurrentLinkedSetQueue<Integer> queue = new ConcurrentLinkedSetQueue<>();
		/* act */
		queue.offer(1);
		queue.offer(2);
		queue.offer(3);
		/* assert */
		assertEquals(3, queue.size());
	}

	@Test
	public void offer_Repeat() {
		/* setup */
		final ConcurrentLinkedSetQueue<Integer> queue = new ConcurrentLinkedSetQueue<>();
		/* act */
		queue.offer(1);
		queue.offer(2);
		queue.offer(2);
		/* assert */
		assertEquals(2, queue.size());
	}

	@Test
	public void offerPollAndOfferAgain() {
		/* setup */
		final ConcurrentLinkedSetQueue<Integer> queue = new ConcurrentLinkedSetQueue<>();
		/* act */
		queue.offer(1);
		queue.offer(2);
		queue.offer(2);
		final Integer firstPoll = queue.poll();
		queue.offer(1);
		final Integer secondPoll = queue.poll();
		final Integer thirdPoll = queue.poll();
		final Integer fourthPoll = queue.poll();
		/* assert */
		assertEquals((Integer) 1, firstPoll);
		assertEquals((Integer) 2, secondPoll);
		assertEquals((Integer) 1, thirdPoll);
		assertNull(fourthPoll);

		assertEquals(0, queue.size());
	}

	@Test
	public void addAll_RepeatedValues() {
		/* setup */
		final ConcurrentLinkedSetQueue<Integer> queue = new ConcurrentLinkedSetQueue<>();
		/* act */
		queue.addAll(Arrays.asList(1, 2, 3));
		queue.addAll(Arrays.asList(2, 3, 4));
		/* assert */
		assertEquals(4, queue.size());
	}

	@Test(expected = IllegalArgumentException.class)
	public void addAll_itself() {
		/* setup */
		final ConcurrentLinkedSetQueue<Integer> queue = new ConcurrentLinkedSetQueue<>();
		/* act */
		queue.addAll(queue);
		/* assert */
		// illegal argument exception
	}

	@Test
	public void removeObject_emptyNull() {
		/* setup */
		final ConcurrentLinkedSetQueue<Integer> queue = new ConcurrentLinkedSetQueue<>();
		/* act */
		final boolean result = queue.remove(null);
		/* assert */
		assertFalse(result);
	}

	@Test
	public void removeObject_andAddAgain() {
		/* setup */
		final ConcurrentLinkedSetQueue<Integer> queue = new ConcurrentLinkedSetQueue<>();
		queue.addAll(Arrays.asList(1, 2));
		/* act */
		final boolean result = queue.remove(1);
		// to ensure that the value is added again
		queue.add(1);
		final Integer firstPoll = queue.poll(); // 2
		final Integer secondPoll = queue.poll(); // 1
		final Integer thirdPoll = queue.poll(); // null

		/* assert */
		assertTrue(result);
		assertEquals((Integer) 2, firstPoll);
		assertEquals((Integer) 1, secondPoll);
		assertNull(thirdPoll);
	}

	@Test
	public void remove_andAddAgain() {
		/* setup */
		final ConcurrentLinkedSetQueue<Integer> queue = new ConcurrentLinkedSetQueue<>();
		queue.addAll(Arrays.asList(1, 2));
		/* act */
		final Integer remove = queue.remove();
		// to ensure that the value is added again
		queue.add(1);
		final Integer firstPoll = queue.poll(); // 2
		final Integer secondPoll = queue.poll(); // 1
		final Integer thirdPoll = queue.poll(); // null

		/* assert */
		assertEquals((Integer) 1, remove);
		assertEquals((Integer) 2, firstPoll);
		assertEquals((Integer) 1, secondPoll);
		assertNull(thirdPoll);
	}

	@Test
	public void clear() {
		/* setup */
		final ConcurrentLinkedSetQueue<Integer> queue = new ConcurrentLinkedSetQueue<>();
		queue.addAll(Arrays.asList(1, 2));
		/* act */
		queue.clear();
		// to ensure that the value is added again
		queue.add(1);
		final Integer firstPoll = queue.poll(); // 1
		final Integer secondPoll = queue.poll(); // null
		/* assert */
		assertEquals((Integer) 1, firstPoll);
		assertNull(secondPoll);
	}

	@Test
	public void removeAll() {
		/* setup */
		final ConcurrentLinkedSetQueue<Integer> queue = new ConcurrentLinkedSetQueue<>();
		queue.addAll(Arrays.asList(1, 2));
		/* act */
		queue.removeAll(Arrays.asList(1));
		// to ensure that the value is added again
		queue.add(1);
		final Integer firstPoll = queue.poll(); // 2
		final Integer secondPoll = queue.poll(); // 1
		final Integer thirdPoll = queue.poll(); // null
		/* assert */
		assertEquals((Integer) 2, firstPoll);
		assertEquals((Integer) 1, secondPoll);
		assertNull(thirdPoll);
	}

	@Test
	public void retainAll() {
		/* setup */
		final ConcurrentLinkedSetQueue<Integer> queue = new ConcurrentLinkedSetQueue<>();
		queue.addAll(Arrays.asList(1, 2));
		/* act */
		queue.retainAll(Arrays.asList(2));
		// to ensure that the value is not added again
		queue.add(2);
		// to ensure that the value is added again
		queue.add(1);
		final Integer firstPoll = queue.poll(); // 2
		final Integer secondPoll = queue.poll(); // 1
		final Integer thirdPoll = queue.poll(); // null
		/* assert */
		assertEquals((Integer) 2, firstPoll);
		assertEquals((Integer) 1, secondPoll);
		assertNull(thirdPoll);
	}

	@Test(expected = IllegalStateException.class)
	public void iterator_remove_withoutNext() {
		/* setup */
		final ConcurrentLinkedSetQueue<Integer> queue = new ConcurrentLinkedSetQueue<>();
		queue.addAll(Arrays.asList(1, 2, 3));
		/* act */
		final Iterator<Integer> iter = queue.iterator();
		iter.remove();
		/* assert */
		// illegal state exception
	}

	@Test(expected = NoSuchElementException.class)
	public void iterator_next_empty() {
		/* setup */
		final ConcurrentLinkedSetQueue<Integer> queue = new ConcurrentLinkedSetQueue<>();
		/* act */
		queue.iterator().next();
	}

}