| /* |
| * Copyright 2016 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| package com.google.gwt.emultest.java8.util; |
| |
| import com.google.gwt.junit.client.GWTTestCase; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Deque; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.PrimitiveIterator; |
| import java.util.Spliterator; |
| import java.util.Spliterators; |
| import java.util.function.Supplier; |
| |
| /** |
| * Tests for Spliterators JRE emulation. |
| */ |
| public class SpliteratorsTest extends GWTTestCase { |
| |
| @Override |
| public String getModuleName() { |
| return "com.google.gwt.emultest.EmulSuite"; |
| } |
| |
| public void testEmptySpliterator() { |
| testSpliterator(new Object[0], Spliterators::emptySpliterator, true); |
| } |
| |
| public void testEmptyDoubleSpliterator() { |
| testDoubleSpliterator(new double[0], Spliterators::emptyDoubleSpliterator, true); |
| } |
| |
| public void testEmptyIntSpliterator() { |
| testIntSpliterator(new int[0], Spliterators::emptyIntSpliterator, true); |
| } |
| |
| public void testEmptyLongSpliterator() { |
| testLongSpliterator(new long[0], Spliterators::emptyLongSpliterator, true); |
| } |
| |
| public void testSpliterator() { |
| final String[] original = {"1", "2", "3", "4"}; |
| testSpliterator(original, () -> Spliterators.spliterator(Arrays.asList(original), 0), true); |
| testSpliterator(original, () -> Spliterators.spliterator(Arrays.asList(original).iterator(), original.length, 0), true); |
| testSpliterator(original, () -> Spliterators.spliteratorUnknownSize(Arrays.asList(original).iterator(), 0), false); |
| testSpliterator(original, () -> Spliterators.spliterator(original, 0), true); |
| testSpliterator(Arrays.copyOfRange(original, 1, 3), () -> Spliterators.spliterator(original, 1, 3, 0), true); |
| } |
| |
| public void testDoubleSpliterator() { |
| final double[] original = {1., 2., 3., 4.}; |
| testDoubleSpliterator(original, () -> Spliterators.spliterator(original, 0), true); |
| testDoubleSpliterator(Arrays.copyOfRange(original, 1, 3), () -> Spliterators.spliterator(original, 1, 3, 0), true); |
| testDoubleSpliterator(original, () -> Spliterators.spliterator(createPrimitiveDoubleIterator(original), original.length, 0), true); |
| } |
| |
| public void testIntSpliterator() { |
| final int[] original = {1, 2, 3, 4}; |
| testIntSpliterator(original, () -> Spliterators.spliterator(original, 0), true); |
| testIntSpliterator(Arrays.copyOfRange(original, 1, 3), () -> Spliterators.spliterator(original, 1, 3, 0), true); |
| testIntSpliterator(original, () -> Spliterators.spliterator(createPrimitiveIntIterator(original), original.length, 0), true); |
| } |
| |
| public void testLongSpliterator() { |
| final long[] original = {1, 2, 3, 4}; |
| testLongSpliterator(original, () -> Spliterators.spliterator(original, 0), true); |
| testLongSpliterator(Arrays.copyOfRange(original, 1, 3), () -> Spliterators.spliterator(original, 1, 3, 0), true); |
| testLongSpliterator(original, () -> Spliterators.spliterator(createPrimitiveLongIterator(original), original.length, 0), true); |
| } |
| |
| public void testIterator() { |
| final String[] original = {"1", "2", "3", "4"}; |
| Spliterator<String> spliterator = Spliterators.spliterator(Arrays.asList(original), 0); |
| Iterator<String> it = Spliterators.iterator(spliterator); |
| |
| try { |
| it.remove(); |
| fail(); |
| } catch (UnsupportedOperationException expected) { |
| } |
| |
| Deque<String> values = new LinkedList<>(Arrays.asList(original)); |
| it.forEachRemaining(value -> assertEquals(values.pop(), value)); |
| assertEquals(0, values.size()); |
| } |
| |
| public void testDoubleIterator() { |
| final double[] original = {1., 2., 3., 4.}; |
| Spliterator.OfDouble spliterator = Spliterators.spliterator(original, 0); |
| PrimitiveIterator.OfDouble it = Spliterators.iterator(spliterator); |
| |
| try { |
| it.remove(); |
| fail(); |
| } catch (UnsupportedOperationException expected) { |
| } |
| |
| Deque<Double> values = new LinkedList<>(toDoubleCollection(original)); |
| it.forEachRemaining((double value) -> assertEquals((double) values.pop(), value)); |
| assertEquals(0, values.size()); |
| } |
| |
| public void testIntIterator() { |
| final int[] original = {1, 2, 3, 4}; |
| Spliterator.OfInt spliterator = Spliterators.spliterator(original, 0); |
| PrimitiveIterator.OfInt it = Spliterators.iterator(spliterator); |
| |
| try { |
| it.remove(); |
| fail(); |
| } catch (UnsupportedOperationException expected) { |
| } |
| |
| Deque<Integer> values = new LinkedList<>(toIntCollection(original)); |
| it.forEachRemaining((int value) -> assertEquals((int) values.pop(), value)); |
| assertEquals(0, values.size()); |
| } |
| |
| public void testLongIterator() { |
| final long[] original = {1, 2, 3, 4}; |
| Spliterator.OfLong spliterator = Spliterators.spliterator(original, 0); |
| PrimitiveIterator.OfLong it = Spliterators.iterator(spliterator); |
| |
| try { |
| it.remove(); |
| fail(); |
| } catch (UnsupportedOperationException expected) { |
| } |
| |
| Deque<Long> values = new LinkedList<>(toLongCollection(original)); |
| it.forEachRemaining((long value) -> assertEquals((long) values.pop(), value)); |
| assertEquals(0, values.size()); |
| } |
| |
| private <T> void testSpliterator(T[] original, Supplier<Spliterator<T>> supplier, boolean sizeKnown) { |
| Spliterator<T> spliterator = supplier.get(); |
| if (sizeKnown) { |
| assertEquals(original.length, spliterator.estimateSize()); |
| assertEquals(original.length, spliterator.getExactSizeIfKnown()); |
| } else { |
| assertEquals(Long.MAX_VALUE, spliterator.estimateSize()); |
| assertEquals(-1L, spliterator.getExactSizeIfKnown()); |
| } |
| |
| Deque<T> values = new LinkedList<>(Arrays.asList(original)); |
| spliterator.forEachRemaining(value -> assertEquals(values.pop(), value)); |
| spliterator.forEachRemaining(value -> fail()); |
| assertEquals(0, values.size()); |
| |
| spliterator = supplier.get(); |
| for (T originalValue : original) { |
| assertTrue(spliterator.tryAdvance(value -> assertEquals(originalValue, value))); |
| } |
| assertFalse(spliterator.tryAdvance(value -> fail())); |
| } |
| |
| private void testDoubleSpliterator(double[] original, Supplier<Spliterator.OfDouble> supplier, boolean sizeKnown) { |
| Spliterator.OfDouble spliterator = supplier.get(); |
| if (sizeKnown) { |
| assertEquals(original.length, spliterator.estimateSize()); |
| assertEquals(original.length, spliterator.getExactSizeIfKnown()); |
| } else { |
| assertEquals(Long.MAX_VALUE, spliterator.estimateSize()); |
| assertEquals(-1L, spliterator.getExactSizeIfKnown()); |
| } |
| |
| Deque<Double> values = new LinkedList<>(toDoubleCollection(original)); |
| spliterator.forEachRemaining((double value) -> assertEquals((double) values.pop(), value)); |
| spliterator.forEachRemaining((double value) -> fail()); |
| assertEquals(0, values.size()); |
| |
| spliterator = supplier.get(); |
| for (double originalValue : original) { |
| assertTrue(spliterator.tryAdvance((double value) -> assertEquals(originalValue, value))); |
| } |
| assertFalse(spliterator.tryAdvance((double value) -> fail())); |
| } |
| |
| private void testIntSpliterator(int[] original, Supplier<Spliterator.OfInt> supplier, boolean sizeKnown) { |
| Spliterator.OfInt spliterator = supplier.get(); |
| if (sizeKnown) { |
| assertEquals(original.length, spliterator.estimateSize()); |
| assertEquals(original.length, spliterator.getExactSizeIfKnown()); |
| } else { |
| assertEquals(Long.MAX_VALUE, spliterator.estimateSize()); |
| assertEquals(-1L, spliterator.getExactSizeIfKnown()); |
| } |
| |
| Deque<Integer> values = new LinkedList<>(toIntCollection(original)); |
| spliterator.forEachRemaining((int value) -> assertEquals((int) values.pop(), value)); |
| spliterator.forEachRemaining((int value) -> fail()); |
| assertEquals(0, values.size()); |
| |
| spliterator = supplier.get(); |
| for (int originalValue : original) { |
| assertTrue(spliterator.tryAdvance((int value) -> assertEquals(originalValue, value))); |
| } |
| assertFalse(spliterator.tryAdvance((int value) -> fail())); |
| } |
| |
| private void testLongSpliterator(long[] original, Supplier<Spliterator.OfLong> supplier, boolean sizeKnown) { |
| Spliterator.OfLong spliterator = supplier.get(); |
| if (sizeKnown) { |
| assertEquals(original.length, spliterator.estimateSize()); |
| assertEquals(original.length, spliterator.getExactSizeIfKnown()); |
| } else { |
| assertEquals(Long.MAX_VALUE, spliterator.estimateSize()); |
| assertEquals(-1L, spliterator.getExactSizeIfKnown()); |
| } |
| |
| Deque<Long> values = new LinkedList<>(toLongCollection(original)); |
| spliterator.forEachRemaining((long value) -> assertEquals((long) values.pop(), value)); |
| spliterator.forEachRemaining((long value) -> fail()); |
| assertEquals(0, values.size()); |
| |
| spliterator = supplier.get(); |
| for (long originalValue : original) { |
| assertTrue(spliterator.tryAdvance((long value) -> assertEquals(originalValue, value))); |
| } |
| assertFalse(spliterator.tryAdvance((long value) -> fail())); |
| } |
| |
| private static Collection<Double> toDoubleCollection(double[] values) { |
| ArrayList<Double> c = new ArrayList<>(); |
| for (double value : values) { |
| c.add(value); |
| } |
| return c; |
| } |
| |
| private static Collection<Integer> toIntCollection(int[] values) { |
| ArrayList<Integer> c = new ArrayList<>(); |
| for (int value : values) { |
| c.add(value); |
| } |
| return c; |
| } |
| |
| private static Collection<Long> toLongCollection(long[] values) { |
| ArrayList<Long> c = new ArrayList<>(); |
| for (long value : values) { |
| c.add(value); |
| } |
| return c; |
| } |
| |
| private static PrimitiveIterator.OfDouble createPrimitiveDoubleIterator(double[] values) { |
| final Iterator<Double> it = toDoubleCollection(values).iterator(); |
| return new PrimitiveIterator.OfDouble() { |
| @Override |
| public double nextDouble() { |
| return it.next(); |
| } |
| |
| @Override |
| public boolean hasNext() { |
| return it.hasNext(); |
| } |
| }; |
| } |
| |
| private static PrimitiveIterator.OfInt createPrimitiveIntIterator(int[] values) { |
| final Iterator<Integer> it = toIntCollection(values).iterator(); |
| return new PrimitiveIterator.OfInt() { |
| @Override |
| public int nextInt() { |
| return it.next(); |
| } |
| |
| @Override |
| public boolean hasNext() { |
| return it.hasNext(); |
| } |
| }; |
| } |
| |
| private static PrimitiveIterator.OfLong createPrimitiveLongIterator(long[] values) { |
| final Iterator<Long> it = toLongCollection(values).iterator(); |
| return new PrimitiveIterator.OfLong() { |
| @Override |
| public long nextLong() { |
| return it.next(); |
| } |
| |
| @Override |
| public boolean hasNext() { |
| return it.hasNext(); |
| } |
| }; |
| } |
| |
| } |