/*
* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.util.stream;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import java.util.*;
import java.util.function.DoubleConsumer;
import java.util.function.IntConsumer;
import java.util.function.LongConsumer;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
@Test
public class SpinedBufferTest {
// Create sizes around the boundary of spines
static List<Integer> sizes;
static {
try {
sizes = IntStream.range(0, 15)
.map(i -> 1 << i)
.flatMap(i -> Arrays.stream(new int[] { i-2, i-1, i, i+1, i+2 }))
.filter(i -> i >= 0)
.boxed()
.distinct()
.collect(Collectors.toList());
}
catch (Exception e) {
e.printStackTrace();
}
}
private static final int TEST_SIZE = 5000;
// SpinedBuffer
@DataProvider(name = "SpinedBuffer")
public Object[][] createSpinedBuffer() {
List<Object[]> params = new ArrayList<>();
for (int size : sizes) {
int[] array = IntStream.range(0, size).toArray();
SpinedBuffer<Integer> sb = new SpinedBuffer<>();
Arrays.stream(array).boxed().forEach(sb);
params.add(new Object[]{array, sb});
sb = new SpinedBuffer<>(size / 2);
Arrays.stream(array).boxed().forEach(sb);
params.add(new Object[]{array, sb});
sb = new SpinedBuffer<>(size);
Arrays.stream(array).boxed().forEach(sb);
params.add(new Object[]{array, sb});
sb = new SpinedBuffer<>(size * 2);
Arrays.stream(array).boxed().forEach(sb);
params.add(new Object[]{array, sb});
}
return params.toArray(new Object[0][]);
}
@Test(dataProvider = "SpinedBuffer")
public void testSpliterator(int[] array, SpinedBuffer<Integer> sb) {
assertEquals(sb.count(), array.length);
assertEquals(sb.count(), sb.spliterator().getExactSizeIfKnown());
SpliteratorTestHelper.testSpliterator(sb::spliterator);
}
@Test(dataProvider = "SpinedBuffer", groups = { "serialization-hostile" })
public void testLastSplit(int[] array, SpinedBuffer<Integer> sb) {
Spliterator<Integer> spliterator = sb.spliterator();
Spliterator<Integer> split = spliterator.trySplit();
long splitSizes = (split == null) ? 0 : split.getExactSizeIfKnown();
long lastSplitSize = spliterator.getExactSizeIfKnown();
splitSizes += lastSplitSize;
assertEquals(splitSizes, array.length);
List<Integer> contentOfLastSplit = new ArrayList<>();
spliterator.forEachRemaining(contentOfLastSplit::add);
assertEquals(contentOfLastSplit.size(), lastSplitSize);
List<Integer> end = Arrays.stream(array)
.boxed()
.substream(array.length - lastSplitSize)
.collect(Collectors.toList());
assertEquals(contentOfLastSplit, end);
}
@Test(groups = { "serialization-hostile" })
public void testSpinedBuffer() {
List<Integer> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();
SpinedBuffer<Integer> sb = new SpinedBuffer<>();
for (int i = 0; i < TEST_SIZE; i++) {
list1.add(i);
sb.accept(i);
}
Iterator<Integer> it = sb.iterator();
for (int i = 0; i < TEST_SIZE; i++)
list2.add(it.next());
assertFalse(it.hasNext());
assertEquals(list1, list2);
for (int i = 0; i < TEST_SIZE; i++)
assertEquals(sb.get(i), (Integer) i, Integer.toString(i));
list2.clear();
sb.forEach(list2::add);
assertEquals(list1, list2);
Integer[] array = sb.asArray(LambdaTestHelpers.integerArrayGenerator);
list2.clear();
for (Integer i : array)
list2.add(i);
assertEquals(list1, list2);
}
// IntSpinedBuffer
@DataProvider(name = "IntSpinedBuffer")
public Object[][] createIntSpinedBuffer() {
List<Object[]> params = new ArrayList<>();
for (int size : sizes) {
int[] array = IntStream.range(0, size).toArray();
SpinedBuffer.OfInt sb = new SpinedBuffer.OfInt();
Arrays.stream(array).forEach(sb);
params.add(new Object[]{array, sb});
}
return params.toArray(new Object[0][]);
}
@Test(dataProvider = "IntSpinedBuffer")
public void testIntSpliterator(int[] array, SpinedBuffer.OfInt sb) {
assertEquals(sb.count(), array.length);
assertEquals(sb.count(), sb.spliterator().getExactSizeIfKnown());
SpliteratorTestHelper.testIntSpliterator(sb::spliterator);
}
@Test(dataProvider = "IntSpinedBuffer", groups = { "serialization-hostile" })
public void testIntLastSplit(int[] array, SpinedBuffer.OfInt sb) {
Spliterator.OfInt spliterator = sb.spliterator();
Spliterator.OfInt split = spliterator.trySplit();
long splitSizes = (split == null) ? 0 : split.getExactSizeIfKnown();
long lastSplitSize = spliterator.getExactSizeIfKnown();
splitSizes += lastSplitSize;
assertEquals(splitSizes, array.length);
List<Integer> contentOfLastSplit = new ArrayList<>();
spliterator.forEachRemaining((IntConsumer) contentOfLastSplit::add);
assertEquals(contentOfLastSplit.size(), lastSplitSize);
List<Integer> end = Arrays.stream(array)
.boxed()
.substream(array.length - lastSplitSize)
.collect(Collectors.toList());
assertEquals(contentOfLastSplit, end);
}
@Test(groups = { "serialization-hostile" })
public void testIntSpinedBuffer() {
List<Integer> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();
SpinedBuffer.OfInt sb = new SpinedBuffer.OfInt();
for (int i = 0; i < TEST_SIZE; i++) {
list1.add(i);
sb.accept(i);
}
PrimitiveIterator.OfInt it = sb.iterator();
for (int i = 0; i < TEST_SIZE; i++)
list2.add(it.nextInt());
assertFalse(it.hasNext());
assertEquals(list1, list2);
for (int i = 0; i < TEST_SIZE; i++)
assertEquals(sb.get(i), i, Integer.toString(i));
list2.clear();
sb.forEach((int i) -> list2.add(i));
assertEquals(list1, list2);
int[] array = sb.asPrimitiveArray();
list2.clear();
for (int i : array)
list2.add(i);
assertEquals(list1, list2);
}
// LongSpinedBuffer
@DataProvider(name = "LongSpinedBuffer")
public Object[][] createLongSpinedBuffer() {
List<Object[]> params = new ArrayList<>();
for (int size : sizes) {
long[] array = LongStream.range(0, size).toArray();
SpinedBuffer.OfLong sb = new SpinedBuffer.OfLong();
Arrays.stream(array).forEach(sb);
params.add(new Object[]{array, sb});
}
return params.toArray(new Object[0][]);
}
@Test(dataProvider = "LongSpinedBuffer")
public void testLongSpliterator(long[] array, SpinedBuffer.OfLong sb) {
assertEquals(sb.count(), array.length);
assertEquals(sb.count(), sb.spliterator().getExactSizeIfKnown());
SpliteratorTestHelper.testLongSpliterator(sb::spliterator);
}
@Test(dataProvider = "LongSpinedBuffer", groups = { "serialization-hostile" })
public void testLongLastSplit(long[] array, SpinedBuffer.OfLong sb) {
Spliterator.OfLong spliterator = sb.spliterator();
Spliterator.OfLong split = spliterator.trySplit();
long splitSizes = (split == null) ? 0 : split.getExactSizeIfKnown();
long lastSplitSize = spliterator.getExactSizeIfKnown();
splitSizes += lastSplitSize;
assertEquals(splitSizes, array.length);
List<Long> contentOfLastSplit = new ArrayList<>();
spliterator.forEachRemaining((LongConsumer) contentOfLastSplit::add);
assertEquals(contentOfLastSplit.size(), lastSplitSize);
List<Long> end = Arrays.stream(array)
.boxed()
.substream(array.length - lastSplitSize)
.collect(Collectors.toList());
assertEquals(contentOfLastSplit, end);
}
@Test(groups = { "serialization-hostile" })
public void testLongSpinedBuffer() {
List<Long> list1 = new ArrayList<>();
List<Long> list2 = new ArrayList<>();
SpinedBuffer.OfLong sb = new SpinedBuffer.OfLong();
for (long i = 0; i < TEST_SIZE; i++) {
list1.add(i);
sb.accept(i);
}
PrimitiveIterator.OfLong it = sb.iterator();
for (int i = 0; i < TEST_SIZE; i++)
list2.add(it.nextLong());
assertFalse(it.hasNext());
assertEquals(list1, list2);
for (int i = 0; i < TEST_SIZE; i++)
assertEquals(sb.get(i), i, Long.toString(i));
list2.clear();
sb.forEach((long i) -> list2.add(i));
assertEquals(list1, list2);
long[] array = sb.asPrimitiveArray();
list2.clear();
for (long i : array)
list2.add(i);
assertEquals(list1, list2);
}
// DoubleSpinedBuffer
@DataProvider(name = "DoubleSpinedBuffer")
public Object[][] createDoubleSpinedBuffer() {
List<Object[]> params = new ArrayList<>();
for (int size : sizes) {
// @@@ replace with double range when implemented
double[] array = LongStream.range(0, size).asDoubleStream().toArray();
SpinedBuffer.OfDouble sb = new SpinedBuffer.OfDouble();
Arrays.stream(array).forEach(sb);
params.add(new Object[]{array, sb});
}
return params.toArray(new Object[0][]);
}
@Test(dataProvider = "DoubleSpinedBuffer")
public void testDoubleSpliterator(double[] array, SpinedBuffer.OfDouble sb) {
assertEquals(sb.count(), array.length);
assertEquals(sb.count(), sb.spliterator().getExactSizeIfKnown());
SpliteratorTestHelper.testDoubleSpliterator(sb::spliterator);
}
@Test(dataProvider = "DoubleSpinedBuffer", groups = { "serialization-hostile" })
public void testLongLastSplit(double[] array, SpinedBuffer.OfDouble sb) {
Spliterator.OfDouble spliterator = sb.spliterator();
Spliterator.OfDouble split = spliterator.trySplit();
long splitSizes = (split == null) ? 0 : split.getExactSizeIfKnown();
long lastSplitSize = spliterator.getExactSizeIfKnown();
splitSizes += lastSplitSize;
assertEquals(splitSizes, array.length);
List<Double> contentOfLastSplit = new ArrayList<>();
spliterator.forEachRemaining((DoubleConsumer) contentOfLastSplit::add);
assertEquals(contentOfLastSplit.size(), lastSplitSize);
List<Double> end = Arrays.stream(array)
.boxed()
.substream(array.length - lastSplitSize)
.collect(Collectors.toList());
assertEquals(contentOfLastSplit, end);
}
@Test(groups = { "serialization-hostile" })
public void testDoubleSpinedBuffer() {
List<Double> list1 = new ArrayList<>();
List<Double> list2 = new ArrayList<>();
SpinedBuffer.OfDouble sb = new SpinedBuffer.OfDouble();
for (long i = 0; i < TEST_SIZE; i++) {
list1.add((double) i);
sb.accept((double) i);
}
PrimitiveIterator.OfDouble it = sb.iterator();
for (int i = 0; i < TEST_SIZE; i++)
list2.add(it.nextDouble());
assertFalse(it.hasNext());
assertEquals(list1, list2);
for (int i = 0; i < TEST_SIZE; i++)
assertEquals(sb.get(i), (double) i, Double.toString(i));
list2.clear();
sb.forEach((double i) -> list2.add(i));
assertEquals(list1, list2);
double[] array = sb.asPrimitiveArray();
list2.clear();
for (double i : array)
list2.add(i);
assertEquals(list1, list2);
}
}