| /******************************************************************************* |
| * Copyright (c) 2009, 2015 Oracle. 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: |
| * Oracle - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.jpt.common.utility.tests.internal.deque; |
| |
| import java.util.NoSuchElementException; |
| import org.eclipse.jpt.common.utility.deque.Deque; |
| import org.eclipse.jpt.common.utility.internal.deque.DequeTools; |
| |
| @SuppressWarnings("nls") |
| public class ReverseDequeTests |
| extends DequeTests |
| { |
| private Deque<String> original; |
| |
| public ReverseDequeTests(String name) { |
| super(name); |
| } |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| this.original = DequeTools.arrayDeque(); |
| } |
| |
| @Override |
| public Deque<String> buildDeque() { |
| return DequeTools.reverse(this.original); |
| } |
| |
| public void testIsEmpty_combo() { |
| Deque<String> queue = this.buildDeque(); |
| assertTrue(queue.isEmpty()); |
| this.original.enqueueTail("first"); |
| assertFalse(queue.isEmpty()); |
| queue.enqueueTail("second"); |
| assertFalse(queue.isEmpty()); |
| this.original.enqueueHead("zero"); |
| assertFalse(queue.isEmpty()); |
| queue.dequeueHead(); |
| assertFalse(queue.isEmpty()); |
| queue.dequeueHead(); |
| assertFalse(queue.isEmpty()); |
| queue.dequeueTail(); |
| assertTrue(queue.isEmpty()); |
| } |
| |
| public void testEnqueueTailAndDequeueTail() { |
| Deque<String> queue = this.buildDeque(); |
| String first = "first"; |
| String second = "second"; |
| |
| this.original.enqueueTail(first); |
| this.original.enqueueTail(second); |
| assertEquals(first, queue.dequeueTail()); |
| assertEquals(second, queue.dequeueTail()); |
| } |
| |
| public void testEnqueueHeadAndDequeueHead() { |
| Deque<String> queue = this.buildDeque(); |
| String first = "first"; |
| String second = "second"; |
| |
| this.original.enqueueHead(first); |
| this.original.enqueueHead(second); |
| assertEquals(first, queue.dequeueHead()); |
| assertEquals(second, queue.dequeueHead()); |
| } |
| |
| public void testEnqueueAndDequeue_combo() { |
| Deque<String> queue = this.buildDeque(); |
| String negative = "negative"; |
| String zero = "zero"; |
| String first = "first"; |
| String second = "second"; |
| |
| this.original.enqueueTail(first); |
| this.original.enqueueTail(second); |
| this.original.enqueueHead(zero); |
| this.original.enqueueHead(negative); |
| assertEquals(negative, queue.dequeueTail()); |
| assertEquals(second, queue.dequeueHead()); |
| assertEquals(zero, queue.dequeueTail()); |
| assertEquals(first, queue.dequeueHead()); |
| |
| assertTrue(queue.isEmpty()); |
| } |
| |
| public void testEnqueueTailAndPeekTail() { |
| Deque<String> queue = this.buildDeque(); |
| String first = "first"; |
| String second = "second"; |
| |
| this.original.enqueueTail(first); |
| this.original.enqueueTail(second); |
| assertEquals(first, queue.peekTail()); |
| assertEquals(first, queue.peekTail()); |
| assertEquals(first, queue.dequeueTail()); |
| assertEquals(second, queue.peekTail()); |
| assertEquals(second, queue.peekTail()); |
| assertEquals(second, queue.dequeueTail()); |
| } |
| |
| public void testEnqueueHeadAndPeekHead() { |
| Deque<String> queue = this.buildDeque(); |
| String first = "first"; |
| String second = "second"; |
| |
| this.original.enqueueHead(first); |
| this.original.enqueueHead(second); |
| assertEquals(first, queue.peekHead()); |
| assertEquals(first, queue.peekHead()); |
| assertEquals(first, queue.dequeueHead()); |
| assertEquals(second, queue.peekHead()); |
| assertEquals(second, queue.peekHead()); |
| assertEquals(second, queue.dequeueHead()); |
| } |
| |
| public void testEnqueueAndPeek_combo() { |
| Deque<String> queue = this.buildDeque(); |
| String negative = "negative"; |
| String zero = "zero"; |
| String first = "first"; |
| String second = "second"; |
| |
| this.original.enqueueTail(first); |
| this.original.enqueueTail(second); |
| this.original.enqueueHead(zero); |
| this.original.enqueueHead(negative); |
| assertEquals(negative, queue.peekTail()); |
| assertEquals(negative, queue.peekTail()); |
| assertEquals(second, queue.peekHead()); |
| assertEquals(second, queue.peekHead()); |
| |
| assertEquals(negative, queue.dequeueTail()); |
| assertEquals(zero, queue.peekTail()); |
| assertEquals(zero, queue.peekTail()); |
| assertEquals(second, queue.peekHead()); |
| assertEquals(second, queue.peekHead()); |
| |
| assertEquals(second, queue.dequeueHead()); |
| assertEquals(zero, queue.peekTail()); |
| assertEquals(first, queue.peekHead()); |
| |
| assertEquals(first, queue.dequeueHead()); |
| assertEquals(zero, queue.peekTail()); |
| assertEquals(zero, queue.peekHead()); |
| |
| assertEquals(zero, queue.dequeueHead()); |
| |
| assertTrue(queue.isEmpty()); |
| } |
| |
| public void testEmptyDequeExceptionPeekTail_combo() { |
| Deque<String> queue = this.buildDeque(); |
| String first = "first"; |
| String second = "second"; |
| |
| this.original.enqueueTail(first); |
| this.original.enqueueTail(second); |
| assertEquals(first, queue.peekTail()); |
| assertEquals(first, queue.dequeueTail()); |
| assertEquals(second, queue.peekTail()); |
| assertEquals(second, queue.dequeueTail()); |
| |
| boolean exCaught = false; |
| try { |
| queue.peekTail(); |
| fail(); |
| } catch (NoSuchElementException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testEmptyDequeExceptionPeekHead_combo() { |
| Deque<String> queue = this.buildDeque(); |
| String first = "first"; |
| String second = "second"; |
| |
| this.original.enqueueHead(first); |
| this.original.enqueueHead(second); |
| assertEquals(first, queue.peekHead()); |
| assertEquals(first, queue.dequeueHead()); |
| assertEquals(second, queue.peekHead()); |
| assertEquals(second, queue.dequeueHead()); |
| |
| boolean exCaught = false; |
| try { |
| queue.peekHead(); |
| fail(); |
| } catch (NoSuchElementException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testEmptyDequeExceptionDequeueTail_combo() { |
| Deque<String> queue = this.buildDeque(); |
| String first = "first"; |
| String second = "second"; |
| |
| this.original.enqueueTail(first); |
| this.original.enqueueTail(second); |
| assertEquals(first, queue.peekTail()); |
| assertEquals(first, queue.dequeueTail()); |
| assertEquals(second, queue.peekTail()); |
| assertEquals(second, queue.dequeueTail()); |
| |
| boolean exCaught = false; |
| try { |
| queue.dequeueTail(); |
| fail(); |
| } catch (NoSuchElementException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testEmptyDequeExceptionDequeueHead_combo() { |
| Deque<String> queue = this.buildDeque(); |
| String first = "first"; |
| String second = "second"; |
| |
| this.original.enqueueHead(first); |
| this.original.enqueueHead(second); |
| assertEquals(first, queue.peekHead()); |
| assertEquals(first, queue.dequeueHead()); |
| assertEquals(second, queue.peekHead()); |
| assertEquals(second, queue.dequeueHead()); |
| |
| boolean exCaught = false; |
| try { |
| queue.dequeueHead(); |
| fail(); |
| } catch (NoSuchElementException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| |
| @Override |
| public void testClone() { |
| // unsupported |
| } |
| |
| @Override |
| public void testToString() throws Exception { |
| Deque<String> queue = this.buildDeque(); |
| assertTrue(queue.toString().startsWith("ReverseDeque")); |
| assertTrue(queue.toString().endsWith("([])")); |
| queue.enqueueTail("first"); |
| assertTrue(queue.toString().startsWith("ReverseDeque")); |
| assertTrue(queue.toString().endsWith("([first])")); |
| queue.enqueueTail("second"); |
| assertTrue(queue.toString().startsWith("ReverseDeque")); |
| assertTrue(queue.toString().endsWith("([second, first])")); |
| queue.enqueueTail("third"); |
| assertTrue(queue.toString().startsWith("ReverseDeque")); |
| assertTrue(queue.toString().endsWith("([third, second, first])")); |
| queue.enqueueHead("foo"); |
| assertTrue(queue.toString().startsWith("ReverseDeque")); |
| assertTrue(queue.toString().endsWith("([third, second, first, foo])")); |
| } |
| |
| public void testCtor_nullDeque() { |
| boolean exCaught = false; |
| try { |
| Deque<String> deque = DequeTools.reverse(null); |
| fail("bogus deque: " + deque); |
| } catch (NullPointerException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| } |