@Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } NFAState nfaState = (NFAState) o; return Arrays.equals(partialMatches.toArray(), nfaState.partialMatches.toArray()) && Arrays.equals(completedMatches.toArray(), nfaState.completedMatches.toArray()); }
@Override public Object[] toArray() { assertTrue(Thread.holdsLock(mutex)); return delegate.toArray(); }
@Override public <T> T[] toArray(T[] array) { assertTrue(Thread.holdsLock(mutex)); return delegate.toArray(array); }
@Test(dataProvider = "empty,singleton,populated") public void toArray(Queue<Integer> queue) { Object[] expect = new ArrayList<>(queue).toArray(); Object[] actual = queue.toArray(); assertThat(actual, queue.isEmpty() ? emptyArray() : arrayContaining(expect)); }
@Test(dataProvider = "empty,singleton,populated") public void toTypedArray(Queue<Integer> queue) { Integer[] expect = new ArrayList<>(queue).toArray(new Integer[] {}); Integer[] actual = queue.toArray(new Integer[] {}); assertThat(actual, queue.isEmpty() ? emptyArray() : arrayContaining(expect)); }
@Test public void offerWithOneLength() throws Exception { Queue<Integer> queue = new ConcurrentEvictingQueue<>(1); assertThat(queue.size()).isEqualTo(0); queue.offer(1); assertThat(queue.toArray()).containsExactly(1); assertThat(queue.size()).isEqualTo(1); queue.offer(2); assertThat(queue.toArray()).containsExactly(2); assertThat(queue.size()).isEqualTo(1); }
@Test public void peek() throws Exception { Queue<Integer> queue = new ConcurrentEvictingQueue<>(2); Integer emptyPeek = queue.peek(); assertThat(emptyPeek).isNull(); queue.offer(1); assertThat(queue.toArray()).containsExactly(1); Integer first = queue.peek(); assertThat(first).isEqualTo(1); assertThat(queue.toArray()).containsExactly(1); queue.offer(2); assertThat(queue.toArray()).containsExactly(1, 2); Integer second = queue.peek(); assertThat(second).isEqualTo(1); assertThat(queue.toArray()).containsExactly(1, 2); }
@Test public void clear() throws Exception { Queue<Integer> queue = new ConcurrentEvictingQueue<>(2); assertThat(queue).isEmpty(); queue.clear(); assertThat(queue).isEmpty(); queue.offer(1); assertThat(queue.toArray()).containsExactly(1); queue.offer(2); assertThat(queue.toArray()).containsExactly(1, 2); queue.clear(); assertThat(queue).isEmpty(); assertThat(queue.size()).isEqualTo(0); queue.offer(3); assertThat(queue.toArray()).containsExactly(3); }
public void testHoldsLockOnAllOperations() { create().element(); create().offer("foo"); create().peek(); create().poll(); create().remove(); create().add("foo"); create().addAll(ImmutableList.of("foo")); create().clear(); create().contains("foo"); create().containsAll(ImmutableList.of("foo")); create().equals(new ArrayDeque<>(ImmutableList.of("foo"))); create().hashCode(); create().isEmpty(); create().iterator(); create().remove("foo"); create().removeAll(ImmutableList.of("foo")); create().retainAll(ImmutableList.of("foo")); create().size(); create().toArray(); create().toArray(new String[] {"foo"}); } }
/** * A deserialized/reserialized deque has same elements in same order */ public void testSerialization() throws Exception { Queue x = populatedDeque(SIZE); Queue y = serialClone(x); assertNotSame(y, x); assertEquals(x.size(), y.size()); assertEquals(x.toString(), y.toString()); assertTrue(Arrays.equals(x.toArray(), y.toArray())); while (!x.isEmpty()) { assertFalse(y.isEmpty()); assertEquals(x.remove(), y.remove()); } assertTrue(y.isEmpty()); }
/** * A deserialized/reserialized queue has same elements in same order */ public void testSerialization() throws Exception { Queue x = populatedQueue(SIZE); Queue y = serialClone(x); assertNotSame(x, y); assertEquals(x.size(), y.size()); assertEquals(x.toString(), y.toString()); assertTrue(Arrays.equals(x.toArray(), y.toArray())); while (!x.isEmpty()) { assertFalse(y.isEmpty()); assertEquals(x.remove(), y.remove()); } assertTrue(y.isEmpty()); }
@Test public void oneQueueWithOneElementShouldConvertToArrayWhenPassedZeroLengthArray() { assertThat(oneQueueWithTestElement(TEST_ELEMENT).toArray(new Integer[0])) .containsExactly(TEST_ELEMENT); }
@Test public void emptyOneQueueShouldConvertToArrayWhenPassedZeroLengthArray() { assertThat(emptyOneQueue().toArray(new Integer[0])).isEmpty(); }
@Test //https://github.com/reactor/reactor-core/issues/1326 public void toArrayOnZeroQueueShouldNotFailAlsoOnJava9() { Queue<Integer> emptyQueue = Queues.<Integer>empty().get(); assertThat(emptyQueue.toArray(new Integer[0])).as("toArray(empty)").isEmpty(); }
@Test public void oneQueueWithOneElementShouldConvertToArrayAndReuseInputArrayWhenPassedOneLengthArray() { Queue<Integer> q = oneQueueWithTestElement(TEST_ELEMENT); //and Integer[] passedArray = new Integer[1]; //when Integer[] convertedArray = q.toArray(passedArray); //then assertThat(convertedArray) .containsExactly(TEST_ELEMENT) .isSameAs(passedArray); }
@Test public void emptyOneQueueShouldConvertToArrayAndPutNullMarkerAndReuseInputArrayOnWhenPassedOneLengthArray() { Queue<Integer> q = emptyOneQueue(); //and Integer[] passedArray = new Integer[1]; //when Integer[] convertedArray = q.toArray(passedArray); //then assertThat(convertedArray) .containsExactly((Integer)null) .isSameAs(passedArray); }
@Test public void testPooledEventsFired() throws Exception { RequestBuilder request = get("http://localhost:" + port1 + "/Test"); try (AsyncHttpClient client = asyncHttpClient()) { EventCollectingHandler firstHandler = new EventCollectingHandler(); client.executeRequest(request, firstHandler).get(3, TimeUnit.SECONDS); firstHandler.waitForCompletion(3, TimeUnit.SECONDS); EventCollectingHandler secondHandler = new EventCollectingHandler(); client.executeRequest(request, secondHandler).get(3, TimeUnit.SECONDS); secondHandler.waitForCompletion(3, TimeUnit.SECONDS); Object[] expectedEvents = new Object[]{CONNECTION_POOL_EVENT, CONNECTION_POOLED_EVENT, REQUEST_SEND_EVENT, HEADERS_WRITTEN_EVENT, STATUS_RECEIVED_EVENT, HEADERS_RECEIVED_EVENT, CONNECTION_OFFER_EVENT, COMPLETED_EVENT}; assertEquals(secondHandler.firedEvents.toArray(), expectedEvents, "Got " + Arrays.toString(secondHandler.firedEvents.toArray())); } } }
@Test public void emptyOneQueueShouldConvertToArrayAndPutNullMarkerAndReuseInputArrayWhenPassedLargerArray() { //given Queue<Integer> q = emptyOneQueue(); //and Integer[] passedArray = {1, 2, 3}; //when Integer[] convertedArray = q.toArray(passedArray); //then assertThat(convertedArray) .hasSize(3) .startsWith(null, 2, 3) .isSameAs(passedArray); }
@Test public void oneQueueWithOneElementShouldConvertToArrayAndPutNullMarkerAndReuseInputArrayWhenPassedLargerArray() { Queue<Integer> q = oneQueueWithTestElement(TEST_ELEMENT); //and Integer[] passedArray = {1, 2, 3}; //given Integer[] convertedArray = q.toArray(passedArray); //then assertThat(convertedArray) .hasSize(3) .startsWith(TEST_ELEMENT, null, 3) .isSameAs(passedArray); }