/** * Determines whether two iterables contain equal elements in the same order. More specifically, * this method returns {@code true} if {@code iterable1} and {@code iterable2} contain the same * number of elements and every element of {@code iterable1} is equal to the corresponding element * of {@code iterable2}. */ public static boolean elementsEqual(Iterable<?> iterable1, Iterable<?> iterable2) { if (iterable1 instanceof Collection && iterable2 instanceof Collection) { Collection<?> collection1 = (Collection<?>) iterable1; Collection<?> collection2 = (Collection<?>) iterable2; if (collection1.size() != collection2.size()) { return false; } } return Iterators.elementsEqual(iterable1.iterator(), iterable2.iterator()); }
/** * Determines whether two iterables contain equal elements in the same order. More specifically, * this method returns {@code true} if {@code iterable1} and {@code iterable2} contain the same * number of elements and every element of {@code iterable1} is equal to the corresponding element * of {@code iterable2}. */ public static boolean elementsEqual(Iterable<?> iterable1, Iterable<?> iterable2) { if (iterable1 instanceof Collection && iterable2 instanceof Collection) { Collection<?> collection1 = (Collection<?>) iterable1; Collection<?> collection2 = (Collection<?>) iterable2; if (collection1.size() != collection2.size()) { return false; } } return Iterators.elementsEqual(iterable1.iterator(), iterable2.iterator()); }
/** An implementation of {@link List#equals(Object)}. */ static boolean equalsImpl(List<?> thisList, @Nullable Object other) { if (other == checkNotNull(thisList)) { return true; } if (!(other instanceof List)) { return false; } List<?> otherList = (List<?>) other; int size = thisList.size(); if (size != otherList.size()) { return false; } if (thisList instanceof RandomAccess && otherList instanceof RandomAccess) { // avoid allocation and use the faster loop for (int i = 0; i < size; i++) { if (!Objects.equal(thisList.get(i), otherList.get(i))) { return false; } } return true; } else { return Iterators.elementsEqual(thisList.iterator(), otherList.iterator()); } }
/** * Determines whether two iterables contain equal elements in the same order. More specifically, * this method returns {@code true} if {@code iterable1} and {@code iterable2} contain the same * number of elements and every element of {@code iterable1} is equal to the corresponding element * of {@code iterable2}. */ public static boolean elementsEqual(Iterable<?> iterable1, Iterable<?> iterable2) { if (iterable1 instanceof Collection && iterable2 instanceof Collection) { Collection<?> collection1 = (Collection<?>) iterable1; Collection<?> collection2 = (Collection<?>) iterable2; if (collection1.size() != collection2.size()) { return false; } } return Iterators.elementsEqual(iterable1.iterator(), iterable2.iterator()); }
/** An implementation of {@link List#equals(Object)}. */ static boolean equalsImpl(List<?> thisList, @NullableDecl Object other) { if (other == checkNotNull(thisList)) { return true; } if (!(other instanceof List)) { return false; } List<?> otherList = (List<?>) other; int size = thisList.size(); if (size != otherList.size()) { return false; } if (thisList instanceof RandomAccess && otherList instanceof RandomAccess) { // avoid allocation and use the faster loop for (int i = 0; i < size; i++) { if (!Objects.equal(thisList.get(i), otherList.get(i))) { return false; } } return true; } else { return Iterators.elementsEqual(thisList.iterator(), otherList.iterator()); } }
/** An implementation of {@link List#equals(Object)}. */ static boolean equalsImpl(List<?> thisList, @NullableDecl Object other) { if (other == checkNotNull(thisList)) { return true; } if (!(other instanceof List)) { return false; } List<?> otherList = (List<?>) other; int size = thisList.size(); if (size != otherList.size()) { return false; } if (thisList instanceof RandomAccess && otherList instanceof RandomAccess) { // avoid allocation and use the faster loop for (int i = 0; i < size; i++) { if (!Objects.equal(thisList.get(i), otherList.get(i))) { return false; } } return true; } else { return Iterators.elementsEqual(thisList.iterator(), otherList.iterator()); } }
@Test(dataProvider = "singleton,populated") public void addAll_whenPopulated(Queue<Integer> queue) { List<Integer> list = ImmutableList.of(POPULATED_SIZE, POPULATED_SIZE + 1, POPULATED_SIZE + 2); List<Integer> expect = ImmutableList.copyOf(Iterables.concat(queue, list)); assertThat(queue.addAll(list), is(true)); assertThat(queue.peek(), is(0)); assertThat(Iterables.getLast(queue), is(POPULATED_SIZE + 2)); assertThat(String.format("%nExpected: %s%n but: %s", queue, expect), elementsEqual(queue.iterator(), expect.iterator())); }
@Test(dataProvider = "singleton,populated") public void iterator_whenPopulated(Queue<Integer> queue) { List<Integer> copy = new ArrayList<>(); populate(copy, queue.size()); assertThat(String.format("%nExpected: %s%n but: %s", queue, copy), elementsEqual(queue.iterator(), copy.iterator())); }
@Test(dataProvider = "empty,singleton,populated") public void serializable(Queue<Integer> queue) { Queue<Integer> copy = SerializableTester.reserialize(queue); assertThat(String.format("%nExpected: %s%n but: %s", queue, copy), elementsEqual(queue.iterator(), copy.iterator())); }
@Override public final boolean equals(Object obj) { if (obj == this) { return true; } if (obj == null || !obj.getClass().equals(TableResult.class)) { return false; } TableResult response = (TableResult) obj; return Objects.equals(getNextPageToken(), response.getNextPageToken()) && Iterators.elementsEqual(getValues().iterator(), response.getValues().iterator()) && Objects.equals(schema, response.schema) && totalRows == response.totalRows; } }
@Test(dataProvider = "empty") public void addAll_whenEmpty(Queue<Integer> queue) { List<Integer> list = new ArrayList<>(); populate(list, POPULATED_SIZE); assertThat(queue.addAll(list), is(true)); assertThat(queue.peek(), is(0)); assertThat(Iterables.getLast(queue), is(POPULATED_SIZE - 1)); assertThat(String.format("%nExpected: %s%n but: %s", queue, list), elementsEqual(queue.iterator(), list.iterator())); }
assertTrue(Iterators.elementsEqual(a.iterator(), b.iterator())); assertTrue(Iterators.elementsEqual(a.iterator(), b.iterator())); assertTrue(Iterators.elementsEqual(a.iterator(), b.iterator())); assertTrue(Iterators.elementsEqual(a.iterator(), b.iterator())); assertFalse(Iterators.elementsEqual(a.iterator(), b.iterator())); assertFalse(Iterators.elementsEqual(a.iterator(), b.iterator())); assertFalse(Iterators.elementsEqual(b.iterator(), a.iterator())); assertFalse(Iterators.elementsEqual(a.iterator(), b.iterator())); assertFalse(Iterators.elementsEqual(b.iterator(), a.iterator())); assertFalse(Iterators.elementsEqual(a.iterator(), b.iterator())); assertFalse(Iterators.elementsEqual(b.iterator(), a.iterator()));
@Test(dataProvider = "full") public void iterator_whenWarmed(LinkedDeque<LinkedValue> deque) { List<LinkedValue> expected = new ArrayList<>(); populate(expected); assertThat(deque.peek(), is(not(nullValue()))); assertThat(elementsEqual(deque.iterator(), expected.iterator()), is(true)); }
@Test(dataProvider = "full") public void descendingIterator_whenWarmed(LinkedDeque<LinkedValue> deque) { List<LinkedValue> expected = new ArrayList<>(); populate(expected); Collections.reverse(expected); assertThat(deque.descendingIterator().peek(), is(not(nullValue()))); assertThat(elementsEqual(deque.descendingIterator(), expected.iterator()), is(true)); }
@ExpectWarning(value="GC", num=5) public static void testIterators(Iterator<String> i, Collection<Integer> c) { Iterators.contains(i, 1); Iterators.removeAll(i,c); Iterators.retainAll(i, c); Iterators.elementsEqual(i, c.iterator()); Iterators.frequency(i, 1); } @NoWarning("GC")
@NoWarning("GC") public static void testIteratorsOK(Iterator<String> i, Collection<String> c) { Iterators.contains(i, "x"); Iterators.removeAll(i,c); Iterators.retainAll(i, c); Iterators.elementsEqual(i, c.iterator()); Iterators.frequency(i, "x"); }
public static <T> boolean isEqual(BatchingVisitable<T> v, final Iterator<T> it) { boolean ret = v.batchAccept(DEFAULT_BATCH_SIZE, batch -> { Iterator<T> toMatch = Iterators.limit(it, batch.size()); return Iterators.elementsEqual(toMatch, batch.iterator()); }); if (it.hasNext()) { return false; } return ret; }
@Test(timeout = 60000) public void testMultipleListeners() throws Exception { TestNamespaceListener listener1 = new TestNamespaceListener(); TestNamespaceListener listener2 = new TestNamespaceListener(); metadataStore.registerNamespaceListener(listener1); metadataStore.registerNamespaceListener(listener2); String logName = "test-multiple-listeners"; URI logUri = FutureUtils.result(metadataStore.createLog(logName)); assertEquals(uri, logUri); listener1.waitForDone(); listener2.waitForDone(); Iterator<String> logsIter1 = listener1.getResult(); Iterator<String> logsIter2 = listener2.getResult(); assertTrue(Iterators.elementsEqual(logsIter1, logsIter2)); }
/** * Determines whether two iterables contain equal elements in the same order. * More specifically, this method returns {@code true} if {@code iterable1} * and {@code iterable2} contain the same number of elements and every element * of {@code iterable1} is equal to the corresponding element of * {@code iterable2}. */ public static boolean elementsEqual( Iterable<?> iterable1, Iterable<?> iterable2) { return Iterators.elementsEqual(iterable1.iterator(), iterable2.iterator()); }
@Override public boolean equals(Object o) { if(!(o instanceof IntervalTree)) return false; IntervalTree that = (IntervalTree)o; return Iterators.elementsEqual(iterator(), that.iterator()); }