user/test/com/google/gwt/emultest/java8/util/SpliteratorsTest.java - gwt - Git at Google

 /*
  * 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();
       }
     };
   }

 }
	/*
	* 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();
	}
	};
	}

	}