stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
Mike Duigou 2013-07-12 12:15:59 -07:00
commit be6f63a1f8
27 changed files with 2865 additions and 877 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
jdk/src/share/classes/java/util/AbstractMap.java
View File

@ -543,6 +543,8 @@ public abstract class AbstractMap<K,V> implements Map<K,V> {
/**
* Utility method for SimpleEntry and SimpleImmutableEntry.
* Test for equality, checking for nulls.
*
* NB: Do not replace with Object.equals until JDK-8015417 is resolved.
*/
private static boolean eq(Object o1, Object o2) {
return o1 == null ? o2 == null : o1.equals(o2);

1033
jdk/src/share/classes/java/util/Collections.java
View File

File diff suppressed because it is too large Load Diff

2
jdk/src/share/classes/java/util/NavigableSet.java
View File

@ -303,7 +303,7 @@ public interface NavigableSet<E> extends SortedSet<E> {
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc}
na */
*/
SortedSet<E> headSet(E toElement);
/**

105
jdk/src/share/classes/java/util/Optional.java
View File

@ -25,6 +25,8 @@
package java.util;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
/**
@ -52,7 +54,7 @@ public final class Optional<T> {
private final T value;
/**
* Construct an empty instance.
* Constructs an empty instance.
*
* @implNote Generally only one empty instance, {@link Optional#EMPTY},
* should exist per VM.
@ -80,7 +82,7 @@ public final class Optional<T> {
}
/**
* Construct an instance with the value present.
* Constructs an instance with the value present.
*
* @param value the non-null value to be present
*/
@ -89,7 +91,7 @@ public final class Optional<T> {
}
/**
* Return an {@code Optional} with the specified present value.
* Returns an {@code Optional} with the specified present non-null value.
*
* @param value the value to be present, which must be non-null
* @return an {@code Optional} with the value present
@ -98,6 +100,18 @@ public final class Optional<T> {
return new Optional<>(value);
}
/**
* Returns an {@code Optional} describing the specified value, if non-null,
* otherwise returns an empty {@code Optional}.
*
* @param value the possibly-null value to describe
* @return an {@code Optional} with a present value if the specified value
* is non-null, otherwise an empty {@code Optional}
*/
public static <T> Optional<T> ofNullable(T value) {
return value == null ? empty() : of(value);
}
/**
* If a value is present in this {@code Optional}, returns the value,
* otherwise throws {@code NoSuchElementException}.
@ -124,7 +138,7 @@ public final class Optional<T> {
}
/**
* Have the specified consumer accept the value if a value is present,
* If a value is present, invoke the specified consumer with the value,
* otherwise do nothing.
*
* @param consumer block to be executed if a value is present
@ -136,6 +150,89 @@ public final class Optional<T> {
consumer.accept(value);
}
/**
* If a value is present, and the value matches the given predicate,
* return an {@code Optional} describing the value, otherwise return an
* empty {@code Optional}.
*
* @param predicate a predicate to apply to the value, if present
* @return an {@code Optional} describing the value of this {@code Optional}
* if a value is present and the value matches the given predicate,
* otherwise an empty {@code Optional}
* @throws NullPointerException if the predicate is null
*/
public Optional<T> filter(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate);
if (!isPresent())
return this;
else
return predicate.test(value) ? this : empty();
}
/**
* If a value is present, apply the provided mapping function to it,
* and if the result is non-null, return an {@code Optional} describing the
* result. Otherwise return an empty {@code Optional}.
*
* @apiNote This method supports post-processing on optional values, without
* the need to explicitly check for a return status. For example, the
* following code traverses a stream of file names, selects one that has
* not yet been processed, and then opens that file, returning an
* {@code Optional<FileInputStream>}:
*
* <pre>{@code
* Optional<FileInputStream> fis =
* names.stream().filter(name -> !isProcessedYet(name))
* .findFirst()
* .map(name -> new FileInputStream(name));
* }</pre>
*
* Here, {@code findFirst} returns an {@code Optional<String>}, and then
* {@code map} returns an {@code Optional<FileInputStream>} for the desired
* file if one exists.
*
* @param <U> The type of the result of the mapping function
* @param mapper a mapping function to apply to the value, if present
* @return an {@code Optional} describing the result of applying a mapping
* function to the value of this {@code Optional}, if a value is present,
* otherwise an empty {@code Optional}
* @throws NullPointerException if the mapping function is null
*/
public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
Objects.requireNonNull(mapper);
if (!isPresent())
return empty();
else {
return Optional.ofNullable(mapper.apply(value));
}
}
/**
* If a value is present, apply the provided {@code Optional}-bearing
* mapping function to it, return that result, otherwise return an empty
* {@code Optional}. This method is similar to {@link #map(Function)},
* but the provided mapper is one whose result is already an {@code Optional},
* and if invoked, {@code flatMap} does not wrap it with an additional
* {@code Optional}.
*
* @param <U> The type parameter to the {@code Optional} returned by
* @param mapper a mapping function to apply to the value, if present
* the mapping function
* @return the result of applying an {@code Optional}-bearing mapping
* function to the value of this {@code Optional}, if a value is present,
* otherwise an empty {@code Optional}
* @throws NullPointerException if the mapping function is null or returns
* a null result
*/
public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
Objects.requireNonNull(mapper);
if (!isPresent())
return empty();
else {
return Objects.requireNonNull(mapper.apply(value));
}
}
/**
* Return the value if present, otherwise return {@code other}.
*

10
jdk/src/share/classes/java/util/OptionalDouble.java
View File

@ -186,10 +186,10 @@ public final class OptionalDouble {
}
/**
* Indicates whether some other object is "equal to" this Optional. The
* Indicates whether some other object is "equal to" this OptionalDouble. The
* other object is considered equal if:
* <ul>
* <li>it is also an {@code OptionalInt} and;
* <li>it is also an {@code OptionalDouble} and;
* <li>both instances have no value present or;
* <li>the present values are "equal to" each other via {@code Double.compare() == 0}.
* </ul>
@ -226,12 +226,14 @@ public final class OptionalDouble {
}
/**
* Returns a non-empty string representation of this OptionalDouble suitable for
* {@inheritDoc}
*
* Returns a non-empty string representation of this object suitable for
* debugging. The exact presentation format is unspecified and may vary
* between implementations and versions.
*
* @implSpec If a value is present the result must include its string
* representation in the result. Empty and present OptionalDoubless must be
* representation in the result. Empty and present instances must be
* unambiguously differentiable.
*
* @return the string representation of this instance

8
jdk/src/share/classes/java/util/OptionalInt.java
View File

@ -186,7 +186,7 @@ public final class OptionalInt {
}
/**
* Indicates whether some other object is "equal to" this Optional. The
* Indicates whether some other object is "equal to" this OptionalInt. The
* other object is considered equal if:
* <ul>
* <li>it is also an {@code OptionalInt} and;
@ -226,12 +226,14 @@ public final class OptionalInt {
}
/**
* Returns a non-empty string representation of this OptionalInt suitable for
* {@inheritDoc}
*
* Returns a non-empty string representation of this object suitable for
* debugging. The exact presentation format is unspecified and may vary
* between implementations and versions.
*
* @implSpec If a value is present the result must include its string
* representation in the result. Empty and present OptionalInts must be
* representation in the result. Empty and present instances must be
* unambiguously differentiable.
*
* @return the string representation of this instance

10
jdk/src/share/classes/java/util/OptionalLong.java
View File

@ -186,10 +186,10 @@ public final class OptionalLong {
}
/**
* Indicates whether some other object is "equal to" this Optional. The
* Indicates whether some other object is "equal to" this OptionalLong. The
* other object is considered equal if:
* <ul>
* <li>it is also an {@code OptionalInt} and;
* <li>it is also an {@code OptionalLong} and;
* <li>both instances have no value present or;
* <li>the present values are "equal to" each other via {@code ==}.
* </ul>
@ -226,12 +226,14 @@ public final class OptionalLong {
}
/**
* Returns a non-empty string representation of this OptionalLong suitable for
* {@inheritDoc}
*
* Returns a non-empty string representation of this object suitable for
* debugging. The exact presentation format is unspecified and may vary
* between implementations and versions.
*
* @implSpec If a value is present the result must include its string
* representation in the result. Empty and present OptionalLongs must be
* representation in the result. Empty and present instances must be
* unambiguously differentiable.
*
* @return the string representation of this instance

22
jdk/src/share/classes/java/util/stream/DoubleStream.java
View File

@ -746,4 +746,26 @@ public interface DoubleStream extends BaseStream<Double, DoubleStream> {
return StreamSupport.doubleStream(
new StreamSpliterators.InfiniteSupplyingSpliterator.OfDouble(Long.MAX_VALUE, s));
}
/**
* Creates a lazy concatenated {@code DoubleStream} whose elements are all the
* elements of a first {@code DoubleStream} succeeded by all the elements of the
* second {@code DoubleStream}. The resulting stream is ordered if both
* of the input streams are ordered, and parallel if either of the input
* streams is parallel.
*
* @param a the first stream
* @param b the second stream to concatenate on to end of the first stream
* @return the concatenation of the two streams
*/
public static DoubleStream concat(DoubleStream a, DoubleStream b) {
Objects.requireNonNull(a);
Objects.requireNonNull(b);
Spliterator.OfDouble split = new Streams.ConcatSpliterator.OfDouble(
a.spliterator(), b.spliterator());
return (a.isParallel() || b.isParallel())
? StreamSupport.doubleParallelStream(split)
: StreamSupport.doubleStream(split);
}
}

22
jdk/src/share/classes/java/util/stream/IntStream.java
View File

@ -800,4 +800,26 @@ public interface IntStream extends BaseStream<Integer, IntStream> {
new Streams.RangeIntSpliterator(startInclusive, endInclusive, true));
}
}
/**
* Creates a lazy concatenated {@code IntStream} whose elements are all the
* elements of a first {@code IntStream} succeeded by all the elements of the
* second {@code IntStream}. The resulting stream is ordered if both
* of the input streams are ordered, and parallel if either of the input
* streams is parallel.
*
* @param a the first stream
* @param b the second stream to concatenate on to end of the first stream
* @return the concatenation of the two streams
*/
public static IntStream concat(IntStream a, IntStream b) {
Objects.requireNonNull(a);
Objects.requireNonNull(b);
Spliterator.OfInt split = new Streams.ConcatSpliterator.OfInt(
a.spliterator(), b.spliterator());
return (a.isParallel() || b.isParallel())
? StreamSupport.intParallelStream(split)
: StreamSupport.intStream(split);
}
}

34
jdk/src/share/classes/java/util/stream/LongStream.java
View File

@ -765,10 +765,8 @@ public interface LongStream extends BaseStream<Long, LongStream> {
// Split the range in two and concatenate
// Note: if the range is [Long.MIN_VALUE, Long.MAX_VALUE) then
// the lower range, [Long.MIN_VALUE, 0) will be further split in two
// long m = startInclusive + Long.divideUnsigned(endExclusive - startInclusive, 2) + 1;
// return Streams.concat(range(startInclusive, m), range(m, endExclusive));
// This is temporary until Streams.concat is supported
throw new UnsupportedOperationException();
long m = startInclusive + Long.divideUnsigned(endExclusive - startInclusive, 2) + 1;
return concat(range(startInclusive, m), range(m, endExclusive));
} else {
return StreamSupport.longStream(
new Streams.RangeLongSpliterator(startInclusive, endExclusive, false));
@ -801,13 +799,33 @@ public interface LongStream extends BaseStream<Long, LongStream> {
// Note: if the range is [Long.MIN_VALUE, Long.MAX_VALUE] then
// the lower range, [Long.MIN_VALUE, 0), and upper range,
// [0, Long.MAX_VALUE], will both be further split in two
// long m = startInclusive + Long.divideUnsigned(endInclusive - startInclusive, 2) + 1;
// return Streams.concat(range(startInclusive, m), rangeClosed(m, endInclusive));
// This is temporary until Streams.concat is supported
throw new UnsupportedOperationException();
long m = startInclusive + Long.divideUnsigned(endInclusive - startInclusive, 2) + 1;
return concat(range(startInclusive, m), rangeClosed(m, endInclusive));
} else {
return StreamSupport.longStream(
new Streams.RangeLongSpliterator(startInclusive, endInclusive, true));
}
}
/**
* Creates a lazy concatenated {@code LongStream} whose elements are all the
* elements of a first {@code LongStream} succeeded by all the elements of the
* second {@code LongStream}. The resulting stream is ordered if both
* of the input streams are ordered, and parallel if either of the input
* streams is parallel.
*
* @param a the first stream
* @param b the second stream to concatenate on to end of the first stream
* @return the concatenation of the two streams
*/
public static LongStream concat(LongStream a, LongStream b) {
Objects.requireNonNull(a);
Objects.requireNonNull(b);
Spliterator.OfLong split = new Streams.ConcatSpliterator.OfLong(
a.spliterator(), b.spliterator());
return (a.isParallel() || b.isParallel())
? StreamSupport.longParallelStream(split)
: StreamSupport.longStream(split);
}
}

25
jdk/src/share/classes/java/util/stream/Stream.java
View File

@ -883,4 +883,29 @@ public interface Stream<T> extends BaseStream<T, Stream<T>> {
return StreamSupport.stream(
new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s));
}
/**
* Creates a lazy concatenated {@code Stream} whose elements are all the
* elements of a first {@code Stream} succeeded by all the elements of the
* second {@code Stream}. The resulting stream is ordered if both
* of the input streams are ordered, and parallel if either of the input
* streams is parallel.
*
* @param <T> The type of stream elements
* @param a the first stream
* @param b the second stream to concatenate on to end of the first
* stream
* @return the concatenation of the two input streams
*/
public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
Objects.requireNonNull(a);
Objects.requireNonNull(b);
@SuppressWarnings("unchecked")
Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>(
(Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
return (a.isParallel() || b.isParallel())
? StreamSupport.parallelStream(split)
: StreamSupport.stream(split);
}
}

145
jdk/src/share/classes/java/util/stream/Streams.java
View File

@ -43,7 +43,7 @@ import java.util.function.LongConsumer;
*
* @since 1.8
*/
class Streams {
final class Streams {
private Streams() {
throw new Error("no instances");
@ -670,4 +670,147 @@ class Streams {
}
}
}
abstract static class ConcatSpliterator<T, T_SPLITR extends Spliterator<T>>
implements Spliterator<T> {
protected final T_SPLITR aSpliterator;
protected final T_SPLITR bSpliterator;
// True when no split has occurred, otherwise false
boolean beforeSplit;
// Never read after splitting
final boolean unsized;
public ConcatSpliterator(T_SPLITR aSpliterator, T_SPLITR bSpliterator) {
this.aSpliterator = aSpliterator;
this.bSpliterator = bSpliterator;
beforeSplit = true;
// The spliterator is unsized before splitting if a and b are
// sized and the sum of the estimates overflows
unsized = aSpliterator.hasCharacteristics(SIZED)
&& aSpliterator.hasCharacteristics(SIZED)
&& aSpliterator.estimateSize() + bSpliterator.estimateSize() < 0;
}
@Override
public T_SPLITR trySplit() {
T_SPLITR ret = beforeSplit ? aSpliterator : (T_SPLITR) bSpliterator.trySplit();
beforeSplit = false;
return ret;
}
@Override
public boolean tryAdvance(Consumer<? super T> consumer) {
boolean hasNext;
if (beforeSplit) {
hasNext = aSpliterator.tryAdvance(consumer);
if (!hasNext) {
beforeSplit = false;
hasNext = bSpliterator.tryAdvance(consumer);
}
}
else
hasNext = bSpliterator.tryAdvance(consumer);
return hasNext;
}
@Override
public void forEachRemaining(Consumer<? super T> consumer) {
if (beforeSplit)
aSpliterator.forEachRemaining(consumer);
bSpliterator.forEachRemaining(consumer);
}
@Override
public long estimateSize() {
if (beforeSplit) {
// If one or both estimates are Long.MAX_VALUE then the sum
// will either be Long.MAX_VALUE or overflow to a negative value
long size = aSpliterator.estimateSize() + bSpliterator.estimateSize();
return (size >= 0) ? size : Long.MAX_VALUE;
}
else {
return bSpliterator.estimateSize();
}
}
@Override
public int characteristics() {
if (beforeSplit) {
// Concatenation loses DISTINCT and SORTED characteristics
return aSpliterator.characteristics() & bSpliterator.characteristics()
& ~(Spliterator.DISTINCT | Spliterator.SORTED
| (unsized ? Spliterator.SIZED | Spliterator.SUBSIZED : 0));
}
else {
return bSpliterator.characteristics();
}
}
@Override
public Comparator<? super T> getComparator() {
if (beforeSplit)
throw new IllegalStateException();
return bSpliterator.getComparator();
}
static class OfRef<T> extends ConcatSpliterator<T, Spliterator<T>> {
OfRef(Spliterator<T> aSpliterator, Spliterator<T> bSpliterator) {
super(aSpliterator, bSpliterator);
}
}
private static abstract class OfPrimitive<T, T_CONS, T_SPLITR extends Spliterator.OfPrimitive<T, T_CONS, T_SPLITR>>
extends ConcatSpliterator<T, T_SPLITR>
implements Spliterator.OfPrimitive<T, T_CONS, T_SPLITR> {
private OfPrimitive(T_SPLITR aSpliterator, T_SPLITR bSpliterator) {
super(aSpliterator, bSpliterator);
}
@Override
public boolean tryAdvance(T_CONS action) {
boolean hasNext;
if (beforeSplit) {
hasNext = aSpliterator.tryAdvance(action);
if (!hasNext) {
beforeSplit = false;
hasNext = bSpliterator.tryAdvance(action);
}
}
else
hasNext = bSpliterator.tryAdvance(action);
return hasNext;
}
@Override
public void forEachRemaining(T_CONS action) {
if (beforeSplit)
aSpliterator.forEachRemaining(action);
bSpliterator.forEachRemaining(action);
}
}
static class OfInt
extends ConcatSpliterator.OfPrimitive<Integer, IntConsumer, Spliterator.OfInt>
implements Spliterator.OfInt {
OfInt(Spliterator.OfInt aSpliterator, Spliterator.OfInt bSpliterator) {
super(aSpliterator, bSpliterator);
}
}
static class OfLong
extends ConcatSpliterator.OfPrimitive<Long, LongConsumer, Spliterator.OfLong>
implements Spliterator.OfLong {
OfLong(Spliterator.OfLong aSpliterator, Spliterator.OfLong bSpliterator) {
super(aSpliterator, bSpliterator);
}
}
static class OfDouble
extends ConcatSpliterator.OfPrimitive<Double, DoubleConsumer, Spliterator.OfDouble>
implements Spliterator.OfDouble {
OfDouble(Spliterator.OfDouble aSpliterator, Spliterator.OfDouble bSpliterator) {
super(aSpliterator, bSpliterator);
}
}
}
}

24
jdk/test/java/util/Collection/MOAT.java
View File

@ -71,6 +71,14 @@ public class MOAT {
testCollection(new LinkedList<Integer>());
testCollection(new LinkedList<Integer>().subList(0,0));
testCollection(new TreeSet<Integer>());
testCollection(Collections.checkedList(new ArrayList<Integer>(), Integer.class));
testCollection(Collections.synchronizedList(new ArrayList<Integer>()));
testCollection(Collections.checkedSet(new HashSet<Integer>(), Integer.class));
testCollection(Collections.checkedSortedSet(new TreeSet<Integer>(), Integer.class));
testCollection(Collections.checkedNavigableSet(new TreeSet<Integer>(), Integer.class));
testCollection(Collections.synchronizedSet(new HashSet<Integer>()));
testCollection(Collections.synchronizedSortedSet(new TreeSet<Integer>()));
testCollection(Collections.synchronizedNavigableSet(new TreeSet<Integer>()));
testCollection(new CopyOnWriteArrayList<Integer>());
testCollection(new CopyOnWriteArrayList<Integer>().subList(0,0));
@ -98,6 +106,12 @@ public class MOAT {
testMap(new Hashtable<Integer,Integer>());
testMap(new ConcurrentHashMap<Integer,Integer>(10, 0.5f));
testMap(new ConcurrentSkipListMap<Integer,Integer>());
testMap(Collections.checkedMap(new HashMap<Integer,Integer>(), Integer.class, Integer.class));
testMap(Collections.checkedSortedMap(new TreeMap<Integer,Integer>(), Integer.class, Integer.class));
testMap(Collections.checkedNavigableMap(new TreeMap<Integer,Integer>(), Integer.class, Integer.class));
testMap(Collections.synchronizedMap(new HashMap<Integer,Integer>()));
testMap(Collections.synchronizedSortedMap(new TreeMap<Integer,Integer>()));
testMap(Collections.synchronizedNavigableMap(new TreeMap<Integer,Integer>()));
// Empty collections
final List<Integer> emptyArray = Arrays.asList(new Integer[]{});
@ -117,19 +131,29 @@ public class MOAT {
testCollection(emptySet);
testEmptySet(emptySet);
testEmptySet(EMPTY_SET);
testEmptySet(Collections.emptySet());
testEmptySet(Collections.emptySortedSet());
testEmptySet(Collections.emptyNavigableSet());
testImmutableSet(emptySet);
List<Integer> emptyList = emptyList();
testCollection(emptyList);
testEmptyList(emptyList);
testEmptyList(EMPTY_LIST);
testEmptyList(Collections.emptyList());
testImmutableList(emptyList);
Map<Integer,Integer> emptyMap = emptyMap();
testMap(emptyMap);
testEmptyMap(emptyMap);
testEmptyMap(EMPTY_MAP);
testEmptyMap(Collections.emptyMap());
testEmptyMap(Collections.emptySortedMap());
testEmptyMap(Collections.emptyNavigableMap());
testImmutableMap(emptyMap);
testImmutableMap(Collections.emptyMap());
testImmutableMap(Collections.emptySortedMap());
testImmutableMap(Collections.emptyNavigableMap());
// Singleton collections
Set<Integer> singletonSet = singleton(1);

47
jdk/test/java/util/Collections/CheckedIdentityMap.java
View File

@ -24,59 +24,42 @@
/*
* @test
* @bug 6585904
* @run testng CheckedIdentityMap
* @summary Checked collections with underlying maps with identity comparisons
*/
import java.util.*;
import static java.util.Collections.*;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNotEquals;
import org.testng.annotations.Test;
public class CheckedIdentityMap {
void test(String[] args) throws Throwable {
@Test
public void testHashCode() {
Map<Integer, Integer> m1 = checkedMap(
new IdentityHashMap<Integer, Integer>(),
Integer.class, Integer.class);
Map<Integer, Integer> m2 = checkedMap(
new IdentityHashMap<Integer, Integer>(),
Integer.class, Integer.class);
// NB: these are unique instances. Compare vs. Integer.valueOf(1)
m1.put(new Integer(1), new Integer(1));
m2.put(new Integer(1), new Integer(1));
Map.Entry<Integer, Integer> e1 = m1.entrySet().iterator().next();
Map.Entry<Integer, Integer> e2 = m2.entrySet().iterator().next();
check(! e1.equals(e2));
check(e1.hashCode() == hashCode(e1));
check(e2.hashCode() == hashCode(e2));
assertNotEquals(e1, e2);
assertEquals(e1.hashCode(), hashCode(e1));
assertEquals(e2.hashCode(), hashCode(e2));
}
int hashCode(Map.Entry<?,?> e) {
static int hashCode(Map.Entry<?,?> e) {
return (System.identityHashCode(e.getKey()) ^
System.identityHashCode(e.getValue()));
}
//--------------------- Infrastructure ---------------------------
volatile int passed = 0, failed = 0;
void pass() {passed++;}
void fail() {failed++; Thread.dumpStack();}
void fail(String msg) {System.err.println(msg); fail();}
void unexpected(Throwable t) {failed++; t.printStackTrace();}
void check(boolean cond) {if (cond) pass(); else fail();}
void equal(Object x, Object y) {
if (x == null ? y == null : x.equals(y)) pass();
else fail(x + " not equal to " + y);}
public static void main(String[] args) throws Throwable {
new CheckedIdentityMap().instanceMain(args);}
void instanceMain(String[] args) throws Throwable {
try {test(args);} catch (Throwable t) {unexpected(t);}
System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
if (failed > 0) throw new AssertionError("Some tests failed");}
abstract class F {abstract void f() throws Throwable;}
void THROWS(Class<? extends Throwable> k, F... fs) {
for (F f : fs)
try {f.f(); fail("Expected " + k.getName() + " not thrown");}
catch (Throwable t) {
if (k.isAssignableFrom(t.getClass())) pass();
else unexpected(t);}}
Thread checkedThread(final Runnable r) {
return new Thread() {public void run() {
try {r.run();} catch (Throwable t) {unexpected(t);}}};}
}

159
jdk/test/java/util/Collections/CheckedMapBash.java
View File

@ -23,76 +23,83 @@
/*
* @test
* @bug 4904067 5023830
* @bug 4904067 5023830 7129185
* @summary Unit test for Collections.checkedMap
* @author Josh Bloch
* @run testng CheckedMapBash
*/
import java.util.*;
import java.util.function.Supplier;
import org.testng.annotations.Test;
import org.testng.annotations.DataProvider;
import static org.testng.Assert.fail;
import static org.testng.Assert.assertTrue;
public class CheckedMapBash {
static Random rnd = new Random();
static Object nil = new Integer(0);
static final Random rnd = new Random();
static final Object nil = new Integer(0);
static final int numItr = 100;
static final int mapSize = 100;
public static void main(String[] args) {
int numItr = 100;
int mapSize = 100;
@Test(dataProvider = "Bash.Supplier<Map<Integer,Integer>>")
public static void testCheckedMap(String description, Supplier<Map<Integer,Integer>> supplier) {
Map m = supplier.get();
Object head = nil;
// Linked List test
for (int i=0; i<numItr; i++) {
Map m = newMap();
Object head = nil;
for (int j=0; j<mapSize; j++) {
Object newHead;
do {
newHead = new Integer(rnd.nextInt());
} while (m.containsKey(newHead));
m.put(newHead, head);
head = newHead;
}
if (m.size() != mapSize)
fail("Size not as expected.");
for (int j=0; j<mapSize; j++) {
Object newHead;
do {
newHead = new Integer(rnd.nextInt());
} while (m.containsKey(newHead));
m.put(newHead, head);
head = newHead;
}
if (m.size() != mapSize)
fail("Size not as expected.");
{
HashMap hm = new HashMap(m);
if (! (hm.hashCode() == m.hashCode() &&
hm.entrySet().hashCode() == m.entrySet().hashCode() &&
hm.keySet().hashCode() == m.keySet().hashCode()))
fail("Incorrect hashCode computation.");
{
HashMap hm = new HashMap(m);
if (! (hm.hashCode() == m.hashCode() &&
hm.entrySet().hashCode() == m.entrySet().hashCode() &&
hm.keySet().hashCode() == m.keySet().hashCode()))
fail("Incorrect hashCode computation.");
if (! (hm.equals(m) &&
hm.entrySet().equals(m.entrySet()) &&
hm.keySet().equals(m.keySet()) &&
m.equals(hm) &&
m.entrySet().equals(hm.entrySet()) &&
m.keySet().equals(hm.keySet())))
fail("Incorrect equals computation.");
}
Map m2 = newMap(); m2.putAll(m);
m2.values().removeAll(m.keySet());
if (m2.size()!= 1 || !m2.containsValue(nil))
fail("Collection views test failed.");
int j=0;
while (head != nil) {
if (!m.containsKey(head))
fail("Linked list doesn't contain a link.");
Object newHead = m.get(head);
if (newHead == null)
fail("Could not retrieve a link.");
m.remove(head);
head = newHead;
j++;
}
if (!m.isEmpty())
fail("Map nonempty after removing all links.");
if (j != mapSize)
fail("Linked list size not as expected.");
if (! (hm.equals(m) &&
hm.entrySet().equals(m.entrySet()) &&
hm.keySet().equals(m.keySet()) &&
m.equals(hm) &&
m.entrySet().equals(hm.entrySet()) &&
m.keySet().equals(hm.keySet())))
fail("Incorrect equals computation.");
}
Map m = newMap();
Map m2 = supplier.get(); m2.putAll(m);
m2.values().removeAll(m.keySet());
if (m2.size()!= 1 || !m2.containsValue(nil))
fail("Collection views test failed.");
int j=0;
while (head != nil) {
if (!m.containsKey(head))
fail("Linked list doesn't contain a link.");
Object newHead = m.get(head);
if (newHead == null)
fail("Could not retrieve a link.");
m.remove(head);
head = newHead;
j++;
}
if (!m.isEmpty())
fail("Map nonempty after removing all links.");
if (j != mapSize)
fail("Linked list size not as expected.");
}
@Test(dataProvider = "Supplier<Map<Integer,Integer>>")
public static void testCheckeMap2(String description, Supplier<Map<Integer,Integer>> supplier) {
Map m = supplier.get();
for (int i=0; i<mapSize; i++)
if (m.put(new Integer(i), new Integer(2*i)) != null)
fail("put returns a non-null value erroenously.");
@ -101,7 +108,7 @@ public class CheckedMapBash {
fail("contains value "+i);
if (m.put(nil, nil) == null)
fail("put returns a null value erroenously.");
Map m2 = newMap(); m2.putAll(m);
Map m2 = supplier.get(); m2.putAll(m);
if (!m.equals(m2))
fail("Clone not equal to original. (1)");
if (!m2.equals(m))
@ -134,16 +141,36 @@ public class CheckedMapBash {
fail("Iterator.remove() failed");
}
static Map newMap() {
Map m = Collections.checkedMap(new HashMap(),
Integer.class, Integer.class);
if (!m.isEmpty())
fail("New instance non empty.");
return m;
@DataProvider(name = "Bash.Supplier<Map<Integer,Integer>>", parallel = true)
public static Iterator<Object[]> bashNavigableMapProvider() {
ArrayList<Object[]> iters = new ArrayList<>(makeCheckedMaps());
iters.ensureCapacity(numItr * iters.size());
for(int each=1; each < numItr; each++) {
iters.addAll( makeCheckedMaps());
}
return iters.iterator();
}
static void fail(String s) {
throw new RuntimeException(s);
@DataProvider(name = "Supplier<Map<Integer,Integer>>", parallel = true)
public static Iterator<Object[]> navigableMapProvider() {
return makeCheckedMaps().iterator();
}
public static Collection<Object[]> makeCheckedMaps() {
return Arrays.asList(
new Object[]{"Collections.checkedMap(HashMap)",
(Supplier) () -> {return Collections.checkedMap(new HashMap(), Integer.class, Integer.class);}},
new Object[]{"Collections.checkedMap(TreeSet(reverseOrder)",
(Supplier) () -> {return Collections.checkedMap(new TreeMap(Collections.reverseOrder()), Integer.class, Integer.class);}},
new Object[]{"Collections.checkedMap(TreeSet).descendingSet()",
(Supplier) () -> {return Collections.checkedMap(new TreeMap().descendingMap(), Integer.class, Integer.class);}},
new Object[]{"Collections.checkedNavigableMap(TreeSet)",
(Supplier) () -> {return Collections.checkedNavigableMap(new TreeMap(), Integer.class, Integer.class);}},
new Object[]{"Collections.checkedNavigableMap(TreeSet(reverseOrder)",
(Supplier) () -> {return Collections.checkedNavigableMap(new TreeMap(Collections.reverseOrder()), Integer.class, Integer.class);}},
new Object[]{"Collections.checkedNavigableMap().descendingSet()",
(Supplier) () -> {return Collections.checkedNavigableMap(new TreeMap().descendingMap(), Integer.class, Integer.class);}}
);
}
}

154
jdk/test/java/util/Collections/CheckedSetBash.java
View File

@ -23,82 +23,93 @@
/*
* @test
* @bug 4904067
* @bug 4904067 7129185
* @summary Unit test for Collections.checkedSet
* @author Josh Bloch
* @run testng CheckedSetBash
*/
import java.util.*;
import java.util.function.Supplier;
import org.testng.annotations.Test;
import org.testng.annotations.DataProvider;
import static org.testng.Assert.fail;
import static org.testng.Assert.assertTrue;
public class CheckedSetBash {
static Random rnd = new Random();
static final int numItr = 100;
static final int setSize = 100;
static final Random rnd = new Random();
public static void main(String[] args) {
int numItr = 100;
int setSize = 100;
@Test(dataProvider = "Supplier<Set<Integer>>")
public static void testCheckedSet(String description, Supplier<Set<Integer>> supplier) {
for (int i=0; i<numItr; i++) {
Set s1 = newSet();
AddRandoms(s1, setSize);
Set<Integer> s1 = supplier.get();
assertTrue(s1.isEmpty());
Set s2 = newSet();
AddRandoms(s2, setSize);
AddRandoms(s1, setSize);
Set intersection = clone(s1);
intersection.retainAll(s2);
Set diff1 = clone(s1); diff1.removeAll(s2);
Set diff2 = clone(s2); diff2.removeAll(s1);
Set union = clone(s1); union.addAll(s2);
Set<Integer> s2 = supplier.get();
if (diff1.removeAll(diff2))
fail("Set algebra identity 2 failed");
if (diff1.removeAll(intersection))
fail("Set algebra identity 3 failed");
if (diff2.removeAll(diff1))
fail("Set algebra identity 4 failed");
if (diff2.removeAll(intersection))
fail("Set algebra identity 5 failed");
if (intersection.removeAll(diff1))
fail("Set algebra identity 6 failed");
if (intersection.removeAll(diff1))
fail("Set algebra identity 7 failed");
assertTrue(s2.isEmpty());
intersection.addAll(diff1); intersection.addAll(diff2);
if (!intersection.equals(union))
fail("Set algebra identity 1 failed");
AddRandoms(s2, setSize);
if (new HashSet(union).hashCode() != union.hashCode())
fail("Incorrect hashCode computation.");
Set<Integer> intersection = clone(s1, supplier);
intersection.retainAll(s2);
Set<Integer> diff1 = clone(s1, supplier); diff1.removeAll(s2);
Set<Integer> diff2 = clone(s2, supplier); diff2.removeAll(s1);
Set<Integer> union = clone(s1, supplier); union.addAll(s2);
Iterator e = union.iterator();
while (e.hasNext())
if (!intersection.remove(e.next()))
fail("Couldn't remove element from copy.");
if (!intersection.isEmpty())
fail("Copy nonempty after deleting all elements.");
if (diff1.removeAll(diff2))
fail("Set algebra identity 2 failed");
if (diff1.removeAll(intersection))
fail("Set algebra identity 3 failed");
if (diff2.removeAll(diff1))
fail("Set algebra identity 4 failed");
if (diff2.removeAll(intersection))
fail("Set algebra identity 5 failed");
if (intersection.removeAll(diff1))
fail("Set algebra identity 6 failed");
if (intersection.removeAll(diff1))
fail("Set algebra identity 7 failed");
e = union.iterator();
while (e.hasNext()) {
Object o = e.next();
if (!union.contains(o))
fail("Set doesn't contain one of its elements.");
e.remove();
if (union.contains(o))
fail("Set contains element after deletion.");
}
if (!union.isEmpty())
fail("Set nonempty after deleting all elements.");
intersection.addAll(diff1); intersection.addAll(diff2);
if (!intersection.equals(union))
fail("Set algebra identity 1 failed");
s1.clear();
if (!s1.isEmpty())
fail("Set nonempty after clear.");
if (new HashSet(union).hashCode() != union.hashCode())
fail("Incorrect hashCode computation.");
Iterator e = union.iterator();
while (e.hasNext())
if (!intersection.remove(e.next()))
fail("Couldn't remove element from copy.");
if (!intersection.isEmpty())
fail("Copy nonempty after deleting all elements.");
e = union.iterator();
while (e.hasNext()) {
Object o = e.next();
if (!union.contains(o))
fail("Set doesn't contain one of its elements.");
e.remove();
if (union.contains(o))
fail("Set contains element after deletion.");
}
if (!union.isEmpty())
fail("Set nonempty after deleting all elements.");
s1.clear();
if (!s1.isEmpty())
fail("Set nonempty after clear.");
}
// Done inefficiently so as to exercise toArray
static Set clone(Set s) {
Set clone = newSet();
List arrayList = Arrays.asList(s.toArray());
static <T> Set<T> clone(Set<T> s, Supplier<Set<T>> supplier) {
Set<T> clone = supplier.get();
List<T> arrayList = Arrays.asList((T[]) s.toArray());
clone.addAll(arrayList);
if (!s.equals(clone))
fail("Set not equal to copy.");
@ -109,13 +120,6 @@ public class CheckedSetBash {
return clone;
}
static Set newSet() {
Set s = Collections.checkedSet(new HashSet(), Integer.class);
if (!s.isEmpty())
fail("New instance non empty.");
return s;
}
static void AddRandoms(Set s, int n) {
for (int i=0; i<n; i++) {
int r = rnd.nextInt() % n;
@ -136,8 +140,30 @@ public class CheckedSetBash {
}
}
static void fail(String s) {
throw new RuntimeException(s);
@DataProvider(name = "Supplier<Set<Integer>>", parallel = true)
public static Iterator<Object[]> navigableSetsProvider() {
ArrayList<Object[]> iters = new ArrayList<>(makeCheckedSets());
iters.ensureCapacity(numItr * iters.size());
for(int each=1; each < numItr; each++) {
iters.addAll( makeCheckedSets());
}
return iters.iterator();
}
public static Collection<Object[]> makeCheckedSets() {
return Arrays.asList(
new Object[]{"Collections.checkedSet(HashSet)",
(Supplier) () -> {return Collections.checkedSet(new HashSet(), Integer.class);}},
new Object[]{"Collections.checkedSet(TreeSet(reverseOrder)",
(Supplier) () -> {return Collections.checkedSet(new TreeSet(Collections.reverseOrder()), Integer.class);}},
new Object[]{"Collections.checkedSet(TreeSet).descendingSet()",
(Supplier) () -> {return Collections.checkedSet(new TreeSet().descendingSet(), Integer.class);}},
new Object[]{"Collections.checkedNavigableSet(TreeSet)",
(Supplier) () -> {return Collections.checkedNavigableSet(new TreeSet(), Integer.class);}},
new Object[]{"Collections.checkedNavigableSet(TreeSet(reverseOrder)",
(Supplier) () -> {return Collections.checkedNavigableSet(new TreeSet(Collections.reverseOrder()), Integer.class);}},
new Object[]{"Collections.checkedNavigableSet().descendingSet()",
(Supplier) () -> {return Collections.checkedNavigableSet(new TreeSet().descendingSet(), Integer.class);}}
);
}
}

59
jdk/test/java/util/Collections/EmptyCollectionSerialization.java
View File

@ -23,13 +23,20 @@
/*
* @test
* @bug 4684279
* @bug 4684279 7129185
* @summary Empty utility collections should be singletons
* @author Josh Bloch
* @run testng EmptyCollectionSerialization
*/
import java.util.*;
import java.util.function.Supplier;
import java.io.*;
import org.testng.annotations.Test;
import org.testng.annotations.DataProvider;
import static org.testng.Assert.fail;
import static org.testng.Assert.assertSame;
public class EmptyCollectionSerialization {
private static Object patheticDeepCopy(Object o) throws Exception {
@ -45,16 +52,48 @@ public class EmptyCollectionSerialization {
return ois.readObject();
}
private static boolean isSingleton(Object o) throws Exception {
return patheticDeepCopy(o) == o;
@Test(dataProvider="SerializableSingletons")
public static void serializableSingletons(String description, Supplier<Object> o) {
try {
Object singleton = o.get();
assertSame(o.get(), singleton, description + ": broken Supplier not returning singleton");
Object copy = patheticDeepCopy(singleton);
assertSame( copy, singleton, description + ": " +
copy.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(copy)) +
" is not the singleton " +
singleton.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(singleton)));
} catch(Exception all) {
fail(description + ": Unexpected Exception", all);
}
}
public static void main(String[] args) throws Exception {
if (!isSingleton(Collections.EMPTY_SET))
throw new Exception("EMPTY_SET");
if (!isSingleton(Collections.EMPTY_LIST))
throw new Exception("EMPTY_LIST");
if (!isSingleton(Collections.EMPTY_MAP))
throw new Exception("EMPTY_MAP");
@DataProvider(name = "SerializableSingletons", parallel = true)
public static Iterator<Object[]> navigableMapProvider() {
return makeSingletons().iterator();
}
public static Collection<Object[]> makeSingletons() {
return Arrays.asList(
new Object[]{"Collections.EMPTY_LIST",
(Supplier) () -> {return Collections.EMPTY_LIST;}},
new Object[]{"Collections.EMPTY_MAP",
(Supplier) () -> {return Collections.EMPTY_MAP;}},
new Object[]{"Collections.EMPTY_SET",
(Supplier) () -> {return Collections.EMPTY_SET;}},
new Object[]{"Collections.singletonMap()",
(Supplier) () -> {return Collections.emptyList();}},
new Object[]{"Collections.emptyMap()",
(Supplier) () -> {return Collections.emptyMap();}},
new Object[]{"Collections.emptySet()",
(Supplier) () -> {return Collections.emptySet();}},
new Object[]{"Collections.emptySortedSet()",
(Supplier) () -> {return Collections.emptySortedSet();}},
new Object[]{"Collections.emptySortedMap()",
(Supplier) () -> {return Collections.emptySortedMap();}},
new Object[]{"Collections.emptyNavigableSet()",
(Supplier) () -> {return Collections.emptyNavigableSet();}},
new Object[]{"Collections.emptyNavigableMap()",
(Supplier) () -> {return Collections.emptyNavigableMap();}}
);
}
}

373
jdk/test/java/util/Collections/EmptyNavigableMap.java Normal file
View File

@ -0,0 +1,373 @@
/*
* Copyright (c) 2011, 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.
*/
/*
* @test
* @bug 4533691 7129185
* @summary Unit test for Collections.emptyNavigableMap
* @run testng EmptyNavigableMap
*/
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.NavigableMap;
import java.util.SortedMap;
import java.util.TreeMap;
import org.testng.annotations.Test;
import org.testng.annotations.DataProvider;
import static org.testng.Assert.fail;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertSame;
public class EmptyNavigableMap {
public static <T> void assertInstance(T actual, Class<? extends T> expected) {
assertInstance(expected.isInstance(actual), null);
}
public static <T> void assertInstance(T actual, Class<? extends T> expected, String message) {
assertTrue(expected.isInstance(actual), ((null != message) ? message : "")
+ " " + (actual == null ? "<null>" : actual.getClass().getSimpleName()) + " != " + expected.getSimpleName() + ". ");
}
public static <T extends Throwable> void assertEmptyNavigableMap(Object obj) {
assertInstance(obj, NavigableMap.class);
assertTrue(((NavigableMap)obj).isEmpty() && (((NavigableMap)obj).size() == 0));
}
public static <T extends Throwable> void assertEmptyNavigableMap(Object obj, String message) {
assertInstance(obj, NavigableMap.class, message);
assertTrue(((NavigableMap)obj).isEmpty() && (((NavigableMap)obj).size() == 0),
((null != message) ? message : "") + " Not empty. ");
}
public interface Thrower<T extends Throwable> {
public void run() throws T;
}
public static <T extends Throwable> void assertThrows(Thrower<T> thrower, Class<T> throwable) {
assertThrows(thrower, throwable, null);
}
public static <T extends Throwable> void assertThrows(Thrower<T> thrower, Class<T> throwable, String message) {
Throwable result;
try {
thrower.run();
fail(((null != message) ? message : "") + "Failed to throw " + throwable.getCanonicalName() + ". ");
return;
} catch (Throwable caught) {
result = caught;
}
assertInstance(result, throwable, ((null != message) ? message : "") + "Failed to throw " + throwable.getCanonicalName() + ". ");
}
public static final boolean isDescending(SortedMap<?,?> set) {
if (null == set.comparator()) {
// natural order
return false;
}
if (Collections.reverseOrder() == set.comparator()) {
// reverse natural order.
return true;
}
if (set.comparator().equals(Collections.reverseOrder(Collections.reverseOrder(set.comparator())))) {
// it's a Collections.reverseOrder(Comparator).
return true;
}
throw new IllegalStateException("can't determine ordering for " + set);
}
/**
* Tests that the comparator is {@code null}.
*/
@Test(dataProvider = "NavigableMap<?,?>", dataProviderClass = EmptyNavigableMap.class)
public void testComparatorIsNull(String description, NavigableMap<?,?> navigableMap) {
Comparator comparator = navigableMap.comparator();
assertTrue(comparator == null || comparator == Collections.reverseOrder(), description + ": Comparator (" + comparator + ") is not null.");
}
/**
* Tests that contains requires Comparable
*/
@Test(dataProvider = "NavigableMap<?,?>", dataProviderClass = EmptyNavigableMap.class)
public void testContainsRequiresComparable(String description, NavigableMap<?,?> navigableMap) {
assertThrows(() -> {
navigableMap.containsKey(new Object());
},
ClassCastException.class,
description + ": Compareable should be required");
}
/**
* Tests that the contains method returns {@code false}.
*/
@Test(dataProvider = "NavigableMap<?,?>", dataProviderClass = EmptyNavigableMap.class)
public void testContains(String description, NavigableMap<?,?> navigableMap) {
assertFalse(navigableMap.containsKey(new Integer(1)),
description + ": Should not contain any elements.");
assertFalse(navigableMap.containsValue(new Integer(1)),
description + ": Should not contain any elements.");
}
/**
* Tests that the containsAll method returns {@code false}.
*/
@Test(dataProvider = "NavigableMap<?,?>", dataProviderClass = EmptyNavigableMap.class)
public void testContainsAll(String description, NavigableMap<?,?> navigableMap) {
TreeMap treeMap = new TreeMap();
treeMap.put("1", 1);
treeMap.put("2", 2);
treeMap.put("3", 3);
assertFalse(navigableMap.equals(treeMap), "Should not contain any elements.");
}
/**
* Tests that the iterator is empty.
*/
@Test(dataProvider = "NavigableMap<?,?>", dataProviderClass = EmptyNavigableMap.class)
public void testEmptyIterator(String description, NavigableMap<?,?> navigableMap) {
assertFalse(navigableMap.keySet().iterator().hasNext(), "The iterator is not empty.");
assertFalse(navigableMap.values().iterator().hasNext(), "The iterator is not empty.");
assertFalse(navigableMap.entrySet().iterator().hasNext(), "The iterator is not empty.");
}
/**
* Tests that the set is empty.
*/
@Test(dataProvider = "NavigableMap<?,?>", dataProviderClass = EmptyNavigableMap.class)
public void testIsEmpty(String description, NavigableMap<?,?> navigableMap) {
assertTrue(navigableMap.isEmpty(), "The set is not empty.");
}
/**
* Tests the headMap() method.
*/
@Test(dataProvider = "NavigableMap<?,?>", dataProviderClass = EmptyNavigableMap.class)
public void testHeadMap(String description, NavigableMap navigableMap) {
assertThrows(
() -> { NavigableMap ss = navigableMap.headMap(null, false); },
NullPointerException.class,
description + ": Must throw NullPointerException for null element");
assertThrows(
() -> { NavigableMap ss = navigableMap.headMap(new Object(), true); },
ClassCastException.class,
description + ": Must throw ClassCastException for non-Comparable element");
NavigableMap ss = navigableMap.headMap("1", false);
assertEmptyNavigableMap(ss, description + ": Returned value is not empty navigable set.");
}
/**
* Tests that the size is 0.
*/
@Test(dataProvider = "NavigableMap<?,?>", dataProviderClass = EmptyNavigableMap.class)
public void testSizeIsZero(String description, NavigableMap<?,?> navigableMap) {
assertTrue(0 == navigableMap.size(), "The size of the set is not 0.");
}
/**
* Tests the subMap() method.
*/
@Test(dataProvider = "NavigableMap<?,?>", dataProviderClass = EmptyNavigableMap.class)
public void testSubMap(String description, NavigableMap navigableMap) {
assertThrows(
() -> {
SortedMap ss = navigableMap.subMap(null, BigInteger.TEN);
},
NullPointerException.class,
description + ": Must throw NullPointerException for null element");
assertThrows(
() -> {
SortedMap ss = navigableMap.subMap(BigInteger.ZERO, null);
},
NullPointerException.class,
description + ": Must throw NullPointerException for null element");
assertThrows(
() -> {
SortedMap ss = navigableMap.subMap(null, null);
},
NullPointerException.class,
description + ": Must throw NullPointerException for null element");
Object obj1 = new Object();
Object obj2 = new Object();
assertThrows(
() -> {
SortedMap ss = navigableMap.subMap(obj1, BigInteger.TEN);
},
ClassCastException.class, description
+ ": Must throw ClassCastException for parameter which is not Comparable.");
assertThrows(
() -> {
SortedMap ss = navigableMap.subMap(BigInteger.ZERO, obj2);
},
ClassCastException.class, description
+ ": Must throw ClassCastException for parameter which is not Comparable.");
assertThrows(
() -> {
SortedMap ss = navigableMap.subMap(obj1, obj2);
},
ClassCastException.class, description
+ ": Must throw ClassCastException for parameter which is not Comparable.");
// minimal range
navigableMap.subMap(BigInteger.ZERO, false, BigInteger.ZERO, false);
navigableMap.subMap(BigInteger.ZERO, false, BigInteger.ZERO, true);
navigableMap.subMap(BigInteger.ZERO, true, BigInteger.ZERO, false);
navigableMap.subMap(BigInteger.ZERO, true, BigInteger.ZERO, true);
Object first = isDescending(navigableMap) ? BigInteger.TEN : BigInteger.ZERO;
Object last = (BigInteger.ZERO == first) ? BigInteger.TEN : BigInteger.ZERO;
assertThrows(
() -> {
navigableMap.subMap(last, true, first, false);
},
IllegalArgumentException.class, description
+ ": Must throw IllegalArgumentException when fromElement is not less then then toElement.");
navigableMap.subMap(first, true, last, false);
}
@Test(dataProvider = "NavigableMap<?,?>", dataProviderClass = EmptyNavigableMap.class)
public void testSubMapRanges(String description, NavigableMap navigableMap) {
Object first = isDescending(navigableMap) ? BigInteger.TEN : BigInteger.ZERO;
Object last = (BigInteger.ZERO == first) ? BigInteger.TEN : BigInteger.ZERO;
NavigableMap subMap = navigableMap.subMap(first, true, last, true);
// same subset
subMap.subMap(first, true, last, true);
// slightly smaller
NavigableMap ns = subMap.subMap(first, false, last, false);
// slight exapansion
assertThrows(() -> {
ns.subMap(first, true, last, true);
},
IllegalArgumentException.class,
description + ": Expansion should not be allowed");
// much smaller
subMap.subMap(first, false, BigInteger.ONE, false);
}
@Test(dataProvider = "NavigableMap<?,?>", dataProviderClass = EmptyNavigableMap.class)
public void testheadMapRanges(String description, NavigableMap navigableMap) {
NavigableMap subMap = navigableMap.headMap(BigInteger.ONE, true);
// same subset
subMap.headMap(BigInteger.ONE, true);
// slightly smaller
NavigableMap ns = subMap.headMap(BigInteger.ONE, false);
// slight exapansion
assertThrows(() -> {
ns.headMap(BigInteger.ONE, true);
},
IllegalArgumentException.class,
description + ": Expansion should not be allowed");
// much smaller
subMap.headMap(isDescending(subMap) ? BigInteger.TEN : BigInteger.ZERO, true);
}
@Test(dataProvider = "NavigableMap<?,?>", dataProviderClass = EmptyNavigableMap.class)
public void testTailMapRanges(String description, NavigableMap navigableMap) {
NavigableMap subMap = navigableMap.tailMap(BigInteger.ONE, true);
// same subset
subMap.tailMap(BigInteger.ONE, true);
// slightly smaller
NavigableMap ns = subMap.tailMap(BigInteger.ONE, false);
// slight exapansion
assertThrows(() -> {
ns.tailMap(BigInteger.ONE, true);
},
IllegalArgumentException.class,
description + ": Expansion should not be allowed");
// much smaller
subMap.tailMap(isDescending(subMap) ? BigInteger.ZERO : BigInteger.TEN, false);
}
/**
* Tests the tailMap() method.
*/
@Test(dataProvider = "NavigableMap<?,?>", dataProviderClass = EmptyNavigableMap.class)
public void testTailMap(String description, NavigableMap navigableMap) {
assertThrows(() -> {
navigableMap.tailMap(null);
},
NullPointerException.class,
description + ": Must throw NullPointerException for null element");
assertThrows(() -> {
navigableMap.tailMap(new Object());
}, ClassCastException.class);
NavigableMap ss = navigableMap.tailMap("1", true);
assertEmptyNavigableMap(ss, description + ": Returned value is not empty navigable set.");
}
@DataProvider(name = "NavigableMap<?,?>", parallel = true)
public static Iterator<Object[]> navigableMapsProvider() {
return makeNavigableMaps().iterator();
}
public static Collection<Object[]> makeNavigableMaps() {
return Arrays.asList(
new Object[]{"UnmodifiableNavigableMap(TreeMap)", Collections.unmodifiableNavigableMap(new TreeMap())},
new Object[]{"UnmodifiableNavigableMap(TreeMap.descendingMap()", Collections.unmodifiableNavigableMap(new TreeMap().descendingMap())},
new Object[]{"UnmodifiableNavigableMap(TreeMap.descendingMap().descendingMap()", Collections.unmodifiableNavigableMap(new TreeMap().descendingMap().descendingMap())},
new Object[]{"emptyNavigableMap()", Collections.emptyNavigableMap()},
new Object[]{"emptyNavigableMap().descendingMap()", Collections.emptyNavigableMap().descendingMap()},
new Object[]{"emptyNavigableMap().descendingMap().descendingMap()", Collections.emptyNavigableMap().descendingMap().descendingMap()}
);
}
}

410
jdk/test/java/util/Collections/EmptyNavigableSet.java Normal file
View File

@ -0,0 +1,410 @@
/*
* Copyright (c) 2011, 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.
*/
/*
* @test
* @bug 4533691 7129185
* @summary Unit test for Collections.emptyNavigableSet
* @run testng EmptyNavigableSet
*/
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.NavigableSet;
import java.util.SortedSet;
import java.util.TreeSet;
import org.testng.annotations.Test;
import org.testng.annotations.DataProvider;
import static org.testng.Assert.fail;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertSame;
public class EmptyNavigableSet {
public static <T> void assertInstance(T actual, Class<? extends T> expected) {
assertInstance(expected.isInstance(actual), null);
}
public static <T> void assertInstance(T actual, Class<? extends T> expected, String message) {
assertTrue(expected.isInstance(actual), ((null != message) ? message : "")
+ " " + (actual == null ? "<null>" : actual.getClass().getSimpleName()) + " != " + expected.getSimpleName() + ". ");
}
public static <T extends Throwable> void assertEmptyNavigableSet(Object obj) {
assertInstance(obj, NavigableSet.class);
assertTrue(((NavigableSet)obj).isEmpty() && (((NavigableSet)obj).size() == 0));
}
public static <T extends Throwable> void assertEmptyNavigableSet(Object obj, String message) {
assertInstance(obj, NavigableSet.class, message);
assertTrue(((NavigableSet)obj).isEmpty() && (((NavigableSet)obj).size() == 0),
((null != message) ? message : "") + " Not empty. ");
}
public interface Thrower<T extends Throwable> {
public void run() throws T;
}
public static <T extends Throwable> void assertThrows(Thrower<T> thrower, Class<T> throwable) {
assertThrows(thrower, throwable, null);
}
public static <T extends Throwable> void assertThrows(Thrower<T> thrower, Class<T> throwable, String message) {
Throwable result;
try {
thrower.run();
fail(((null != message) ? message : "") + "Failed to throw " + throwable.getCanonicalName() + ". ");
return;
} catch (Throwable caught) {
result = caught;
}
assertInstance(result, throwable, ((null != message) ? message : "") + "Failed to throw " + throwable.getCanonicalName() + ". ");
}
public static final boolean isDescending(SortedSet<?> set) {
if (null == set.comparator()) {
// natural order
return false;
}
if (Collections.reverseOrder() == set.comparator()) {
// reverse natural order.
return true;
}
if (set.comparator().equals(Collections.reverseOrder(Collections.reverseOrder(set.comparator())))) {
// it's a Collections.reverseOrder(Comparator).
return true;
}
throw new IllegalStateException("can't determine ordering for " + set);
}
/**
* Tests that the comparator is {@code null}.
*/
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testComparatorIsNull(String description, NavigableSet<?> navigableSet) {
Comparator comparator = navigableSet.comparator();
assertTrue(comparator == null || comparator == Collections.reverseOrder(), description + ": Comparator (" + comparator + ") is not null.");
}
/**
* Tests that contains requires Comparable
*/
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testContainsRequiresComparable(String description, NavigableSet<?> navigableSet) {
assertThrows(() -> {
navigableSet.contains(new Object());
},
ClassCastException.class,
description + ": Compareable should be required");
}
/**
* Tests that the contains method returns {@code false}.
*/
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testContains(String description, NavigableSet<?> navigableSet) {
assertFalse(navigableSet.contains(new Integer(1)),
description + ": Should not contain any elements.");
}
/**
* Tests that the containsAll method returns {@code false}.
*/
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testContainsAll(String description, NavigableSet<?> navigableSet) {
TreeSet treeSet = new TreeSet();
treeSet.add("1");
treeSet.add("2");
treeSet.add("3");
assertFalse(navigableSet.containsAll(treeSet), "Should not contain any elements.");
}
/**
* Tests that the iterator is empty.
*/
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testEmptyIterator(String description, NavigableSet<?> navigableSet) {
Iterator emptyIterator = navigableSet.iterator();
assertFalse((emptyIterator != null) && (emptyIterator.hasNext()),
"The iterator is not empty.");
}
/**
* Tests that the set is empty.
*/
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testIsEmpty(String description, NavigableSet<?> navigableSet) {
assertTrue(navigableSet.isEmpty(), "The set is not empty.");
}
/**
* Tests that the first() method throws NoSuchElementException
*/
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testFirst(String description, NavigableSet<?> navigableSet) {
assertThrows(() -> {
navigableSet.first();
}, NoSuchElementException.class, description);
}
/**
* Tests the headSet() method.
*/
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testHeadSet(String description, NavigableSet navigableSet) {
assertThrows(
() -> { NavigableSet ns = navigableSet.headSet(null, false); },
NullPointerException.class,
description + ": Must throw NullPointerException for null element");
assertThrows(
() -> { NavigableSet ns = navigableSet.headSet(new Object(), true); },
ClassCastException.class,
description + ": Must throw ClassCastException for non-Comparable element");
NavigableSet ns = navigableSet.headSet("1", false);
assertEmptyNavigableSet(ns, description + ": Returned value is not empty navigable set.");
}
/**
* Tests that the last() method throws NoSuchElementException
*/
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testLast(String description, NavigableSet<?> navigableSet) {
assertThrows(() -> {
navigableSet.last();
}, NoSuchElementException.class, description);
}
/**
* Tests that the size is 0.
*/
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testSizeIsZero(String description, NavigableSet<?> navigableSet) {
assertTrue(0 == navigableSet.size(), "The size of the set is not 0.");
}
/**
* Tests the subSet() method.
*/
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testSubSet(String description, NavigableSet navigableSet) {
assertThrows(
() -> {
SortedSet ss = navigableSet.subSet(null, BigInteger.TEN);
},
NullPointerException.class,
description + ": Must throw NullPointerException for null element");
assertThrows(
() -> {
SortedSet ss = navigableSet.subSet(BigInteger.ZERO, null);
},
NullPointerException.class,
description + ": Must throw NullPointerException for null element");
assertThrows(
() -> {
SortedSet ss = navigableSet.subSet(null, null);
},
NullPointerException.class,
description + ": Must throw NullPointerException for null element");
Object obj1 = new Object();
Object obj2 = new Object();
assertThrows(
() -> {
SortedSet ss = navigableSet.subSet(obj1, BigInteger.TEN);
},
ClassCastException.class, description
+ ": Must throw ClassCastException for parameter which is not Comparable.");
assertThrows(
() -> {
SortedSet ss = navigableSet.subSet(BigInteger.ZERO, obj2);
},
ClassCastException.class, description
+ ": Must throw ClassCastException for parameter which is not Comparable.");
assertThrows(
() -> {
SortedSet ss = navigableSet.subSet(obj1, obj2);
},
ClassCastException.class, description
+ ": Must throw ClassCastException for parameter which is not Comparable.");
// minimal range
navigableSet.subSet(BigInteger.ZERO, false, BigInteger.ZERO, false);
navigableSet.subSet(BigInteger.ZERO, false, BigInteger.ZERO, true);
navigableSet.subSet(BigInteger.ZERO, true, BigInteger.ZERO, false);
navigableSet.subSet(BigInteger.ZERO, true, BigInteger.ZERO, true);
Object first = isDescending(navigableSet) ? BigInteger.TEN : BigInteger.ZERO;
Object last = (BigInteger.ZERO == first) ? BigInteger.TEN : BigInteger.ZERO;
assertThrows(
() -> {
navigableSet.subSet(last, true, first, false);
},
IllegalArgumentException.class, description
+ ": Must throw IllegalArgumentException when fromElement is not less then then toElement.");
navigableSet.subSet(first, true, last, false);
}
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testSubSetRanges(String description, NavigableSet navigableSet) {
Object first = isDescending(navigableSet) ? BigInteger.TEN : BigInteger.ZERO;
Object last = (BigInteger.ZERO == first) ? BigInteger.TEN : BigInteger.ZERO;
NavigableSet subSet = navigableSet.subSet(first, true, last, true);
// same subset
subSet.subSet(first, true, last, true);
// slightly smaller
NavigableSet ns = subSet.subSet(first, false, last, false);
// slight exapansion
assertThrows(() -> {
ns.subSet(first, true, last, true);
},
IllegalArgumentException.class,
description + ": Expansion should not be allowed");
// much smaller
subSet.subSet(first, false, BigInteger.ONE, false);
}
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testheadSetRanges(String description, NavigableSet navigableSet) {
NavigableSet subSet = navigableSet.headSet(BigInteger.ONE, true);
// same subset
subSet.headSet(BigInteger.ONE, true);
// slightly smaller
NavigableSet ns = subSet.headSet(BigInteger.ONE, false);
// slight exapansion
assertThrows(() -> {
ns.headSet(BigInteger.ONE, true);
},
IllegalArgumentException.class,
description + ": Expansion should not be allowed");
// much smaller
subSet.headSet(isDescending(subSet) ? BigInteger.TEN : BigInteger.ZERO, true);
}
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testTailSetRanges(String description, NavigableSet navigableSet) {
NavigableSet subSet = navigableSet.tailSet(BigInteger.ONE, true);
// same subset
subSet.tailSet(BigInteger.ONE, true);
// slightly smaller
NavigableSet ns = subSet.tailSet(BigInteger.ONE, false);
// slight exapansion
assertThrows(() -> {
ns.tailSet(BigInteger.ONE, true);
},
IllegalArgumentException.class,
description + ": Expansion should not be allowed");
// much smaller
subSet.tailSet(isDescending(subSet) ? BigInteger.ZERO : BigInteger.TEN, false);
}
/**
* Tests the tailSet() method.
*/
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testTailSet(String description, NavigableSet navigableSet) {
assertThrows(() -> {
navigableSet.tailSet(null);
},
NullPointerException.class,
description + ": Must throw NullPointerException for null element");
assertThrows(() -> {
navigableSet.tailSet(new Object());
}, ClassCastException.class);
NavigableSet ss = navigableSet.tailSet("1", true);
assertEmptyNavigableSet(ss, description + ": Returned value is not empty navigable set.");
}
/**
* Tests that the array has a size of 0.
*/
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testToArray(String description, NavigableSet<?> navigableSet) {
Object[] emptyNavigableSetArray = navigableSet.toArray();
assertTrue(emptyNavigableSetArray.length == 0, "Returned non-empty Array.");
emptyNavigableSetArray = new Object[20];
Object[] result = navigableSet.toArray(emptyNavigableSetArray);
assertSame(emptyNavigableSetArray, result);
assertTrue(result[0] == null);
}
@DataProvider(name = "NavigableSet<?>", parallel = true)
public static Iterator<Object[]> navigableSetsProvider() {
return makeNavigableSets().iterator();
}
public static Collection<Object[]> makeNavigableSets() {
return Arrays.asList(
new Object[]{"UnmodifiableNavigableSet(TreeSet)", Collections.unmodifiableNavigableSet(new TreeSet())},
new Object[]{"UnmodifiableNavigableSet(TreeSet.descendingSet()", Collections.unmodifiableNavigableSet(new TreeSet().descendingSet())},
new Object[]{"UnmodifiableNavigableSet(TreeSet.descendingSet().descendingSet()", Collections.unmodifiableNavigableSet(new TreeSet().descendingSet().descendingSet())},
new Object[]{"emptyNavigableSet()", Collections.emptyNavigableSet()},
new Object[]{"emptyNavigableSet().descendingSet()", Collections.emptyNavigableSet().descendingSet()},
new Object[]{"emptyNavigableSet().descendingSet().descendingSet()", Collections.emptyNavigableSet().descendingSet().descendingSet()}
);
}
}

351
jdk/test/java/util/Collections/EmptySortedSet.java
View File

@ -1,351 +0,0 @@
/*
* Copyright (c) 2011, 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.
*/
/*
* @test
* @bug 4533691
* @summary Unit test for Collections.emptySortedSet
*/
import java.lang.reflect.Method;
import java.math.BigInteger;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.SortedSet;
import java.util.TreeSet;
public class EmptySortedSet {
static int status = 0;
private static final String FAILED = " failed. ";
private static final String PERIOD = ".";
private final String thisClassName = this.getClass().getName();
public static void main(String[] args) throws Exception {
new EmptySortedSet();
}
public EmptySortedSet() throws Exception {
run();
}
/**
* Returns {@code true} if the {@link Object} passed in is an empty
* {@link SortedSet}.
*
* @param obj the object to test
* @return {@code true} if the {@link Object} is an empty {@link SortedSet}
* otherwise {@code false}.
*/
private boolean isEmptySortedSet(Object obj) {
boolean isEmptySortedSet = false;
// We determine if the object is an empty sorted set by testing if it's
// an instance of SortedSet, and if so, if it's empty. Currently the
// testing doesn't include checks of the other methods.
if (obj instanceof SortedSet) {
SortedSet ss = (SortedSet) obj;
if ((ss.isEmpty()) && (ss.size() == 0)) {
isEmptySortedSet = true;
}
}
return isEmptySortedSet;
}
private void run() throws Exception {
Method[] methods = this.getClass().getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
String methodName = method.getName();
if (methodName.startsWith("test")) {
try {
Object obj = method.invoke(this, new Object[0]);
} catch(Exception e) {
throw new Exception(this.getClass().getName() + "." +
methodName + " test failed, test exception "
+ "follows\n" + e.getCause());
}
}
}
}
private void throwException(String methodName, String reason)
throws Exception
{
StringBuilder sb = new StringBuilder(thisClassName);
sb.append(PERIOD);
sb.append(methodName);
sb.append(FAILED);
sb.append(reason);
throw new Exception(sb.toString());
}
/**
*
*/
private void test00() throws Exception {
//throwException("test00", "This test has not been implemented yet.");
}
/**
* Tests that the comparator is {@code null}.
*/
private void testComparatorIsNull() throws Exception {
SortedSet sortedSet = Collections.emptySortedSet();
Comparator comparator = sortedSet.comparator();
if (comparator != null) {
throwException("testComparatorIsNull", "Comparator is not null.");
}
}
/**
* Tests that the contains method returns {@code false}.
*/
private void testContains() throws Exception {
SortedSet sortedSet = Collections.emptySortedSet();
if (sortedSet.contains(new Object())) {
throwException("testContains", "Should not contain any elements.");
}
}
/**
* Tests that the containsAll method returns {@code false}.
*/
private void testContainsAll() throws Exception {
SortedSet sortedSet = Collections.emptySortedSet();
TreeSet treeSet = new TreeSet();
treeSet.add("1");
treeSet.add("2");
treeSet.add("3");
if (sortedSet.containsAll(treeSet)) {
throwException("testContainsAll",
"Should not contain any elements.");
}
}
/**
* Tests that the iterator is empty.
*/
private void testEmptyIterator() throws Exception {
SortedSet sortedSet = Collections.emptySortedSet();
Iterator emptyIterator = sortedSet.iterator();
if ((emptyIterator != null) && (emptyIterator.hasNext())) {
throwException("testEmptyIterator", "The iterator is not empty.");
}
}
/**
* Tests that the set is empty.
*/
private void testIsEmpty() throws Exception {
SortedSet sortedSet = Collections.emptySortedSet();
if ((sortedSet != null) && (!sortedSet.isEmpty())) {
throwException("testSizeIsZero", "The set is not empty.");
}
}
/**
* Tests that the first() method throws NoSuchElementException
*/
private void testFirst() throws Exception {
SortedSet sortedSet = Collections.emptySortedSet();
try {
sortedSet.first();
throwException("testFirst",
"NoSuchElemenException was not thrown.");
} catch(NoSuchElementException nsee) {
// Do nothing
}
}
/**
* Tests the headSet() method.
*/
private void testHeadSet() throws Exception {
SortedSet sortedSet = Collections.emptySortedSet();
SortedSet ss;
try {
ss = sortedSet.headSet(null);
throwException("testHeadSet",
"Must throw NullPointerException for null element");
} catch(NullPointerException npe) {
// Do nothing
}
try {
ss = sortedSet.headSet(new Object());
throwException("testHeadSet",
"Must throw ClassCastException for non-Comparable element");
} catch(ClassCastException cce) {
// Do nothing.
}
ss = sortedSet.headSet("1");
if ((ss == null) || !isEmptySortedSet(ss)) {
throwException("testHeadSet",
"Returned value is null or not an EmptySortedSet.");
}
}
/**
* Tests that the last() method throws NoSuchElementException
*/
private void testLast() throws Exception {
SortedSet sortedSet = Collections.emptySortedSet();
try {
sortedSet.last();
throwException("testLast",
"NoSuchElemenException was not thrown.");
} catch(NoSuchElementException nsee) {
// Do nothing
}
}
/**
* Tests that the size is 0.
*/
private void testSizeIsZero() throws Exception {
SortedSet sortedSet = Collections.emptySortedSet();
int size = sortedSet.size();
if (size > 0) {
throwException("testSizeIsZero",
"The size of the set is greater then 0.");
}
}
/**
* Tests the subSet() method.
*/
private void testSubSet() throws Exception {
SortedSet sortedSet = Collections.emptySortedSet();
SortedSet ss = sortedSet.headSet("1");
try {
ss = sortedSet.subSet(null, BigInteger.TEN);
ss = sortedSet.subSet(BigInteger.ZERO, null);
ss = sortedSet.subSet(null, null);
throwException("testSubSet",
"Must throw NullPointerException for null element");
} catch(NullPointerException npe) {
// Do nothing
}
try {
Object obj1 = new Object();
Object obj2 = new Object();
ss = sortedSet.subSet(obj1, BigInteger.TEN);
ss = sortedSet.subSet(BigInteger.ZERO, obj2);
ss = sortedSet.subSet(obj1, obj2);
throwException("testSubSet",
"Must throw ClassCastException for parameter which is "
+ "not Comparable.");
} catch(ClassCastException cce) {
// Do nothing.
}
try {
ss = sortedSet.subSet(BigInteger.ZERO, BigInteger.ZERO);
ss = sortedSet.subSet(BigInteger.TEN, BigInteger.ZERO);
throwException("testSubSet",
"Must throw IllegalArgumentException when fromElement is "
+ "not less then then toElement.");
} catch(IllegalArgumentException iae) {
// Do nothing.
}
ss = sortedSet.subSet(BigInteger.ZERO, BigInteger.TEN);
if (!isEmptySortedSet(ss)) {
throw new Exception("Returned value is not empty sorted set.");
}
}
/**
* Tests the tailSet() method.
*/
private void testTailSet() throws Exception {
SortedSet sortedSet = Collections.emptySortedSet();
SortedSet ss;
try {
ss = sortedSet.tailSet(null);
throwException("testTailSet",
"Must throw NullPointerException for null element");
} catch(NullPointerException npe) {
// Do nothing
}
try {
SortedSet ss2 = sortedSet.tailSet(new Object());
throwException("testTailSet",
"Must throw ClassCastException for non-Comparable element");
} catch(ClassCastException cce) {
// Do nothing.
}
ss = sortedSet.tailSet("1");
if ((ss == null) || !isEmptySortedSet(ss)) {
throwException("testTailSet",
"Returned value is null or not an EmptySortedSet.");
}
}
/**
* Tests that the array has a size of 0.
*/
private void testToArray() throws Exception {
SortedSet sortedSet = Collections.emptySortedSet();
Object[] emptySortedSetArray = sortedSet.toArray();
if ((emptySortedSetArray == null) || (emptySortedSetArray.length > 0)) {
throwException("testToArray",
"Returned null array or array with length > 0.");
}
String[] strings = new String[2];
strings[0] = "1";
strings[1] = "2";
emptySortedSetArray = sortedSet.toArray(strings);
if ((emptySortedSetArray == null) || (emptySortedSetArray[0] != null)) {
throwException("testToArray",
"Returned null array or array with length > 0.");
}
}
}

9
jdk/test/java/util/Map/LockStep.java
View File

@ -100,7 +100,14 @@ public class LockStep {
new Hashtable(16),
new TreeMap(),
new ConcurrentHashMap(16),
new ConcurrentSkipListMap() });
new ConcurrentSkipListMap(),
Collections.checkedMap(new HashMap(16), Integer.class, Integer.class),
Collections.checkedSortedMap(new TreeMap(), Integer.class, Integer.class),
Collections.checkedNavigableMap(new TreeMap(), Integer.class, Integer.class),
Collections.synchronizedMap(new HashMap(16)),
Collections.synchronizedSortedMap(new TreeMap()),
Collections.synchronizedNavigableMap(new TreeMap())
});
for (int j = 0; j < 10; j++)
put(maps, r.nextInt(100), r.nextInt(100));

45
jdk/test/java/util/NavigableMap/LockStep.java
View File

@ -55,11 +55,19 @@ public class LockStep {
lockSteps(new TreeMap(),
new ConcurrentSkipListMap());
lockSteps(new TreeMap(),
Collections.checkedNavigableMap(new TreeMap(), Integer.class, Integer.class));
lockSteps(new TreeMap(),
Collections.synchronizedNavigableMap(new TreeMap()));
lockSteps(new TreeMap(reverseOrder()),
new ConcurrentSkipListMap(reverseOrder()));
lockSteps(new TreeSet(),
new ConcurrentSkipListSet());
lockSteps(new TreeSet(),
Collections.checkedNavigableSet(new TreeSet(), Integer.class));
lockSteps(new TreeSet(),
Collections.synchronizedNavigableSet(new TreeSet()));
lockSteps(new TreeSet(reverseOrder()),
new ConcurrentSkipListSet(reverseOrder()));
}
@ -181,7 +189,15 @@ public class LockStep {
testEmptyCollection(m.values());
}
static final Random rnd = new Random();
static final Random rnd;
static {
// sufficiently random for this test
long seed = System.nanoTime();
System.out.println(LockStep.class.getCanonicalName() + ": Trial random seed: " + seed );
rnd = new Random(seed);
}
static void equalNext(final Iterator<?> it, Object expected) {
if (maybe(2))
@ -208,8 +224,15 @@ public class LockStep {
check(s.descendingSet().descendingSet().comparator() == null);
equal(s.isEmpty(), s.size() == 0);
equal2(s, s.descendingSet());
if (maybe(4) && s instanceof Serializable)
equal2(s, serialClone(s));
if (maybe(4) && s instanceof Serializable) {
try {
equal2(s, serialClone(s));
} catch(RuntimeException uhoh) {
if(!(uhoh.getCause() instanceof NotSerializableException)) {
throw uhoh;
}
}
}
Comparator cmp = comparator(s);
if (s.isEmpty()) {
THROWS(NoSuchElementException.class,
@ -276,6 +299,15 @@ public class LockStep {
check(! it2.hasNext());
}
static void equalSetsLeaf(final Set s1, final Set s2) {
equal2(s1, s2);
equal( s1.size(), s2.size());
equal( s1.isEmpty(), s2.isEmpty());
equal( s1.hashCode(), s2.hashCode());
equal( s1.toString(), s2.toString());
equal( s1.containsAll(s2), s2.containsAll(s1));
}
static void equalNavigableSetsLeaf(final NavigableSet s1,
final NavigableSet s2) {
equal2(s1, s2);
@ -448,8 +480,7 @@ public class LockStep {
static void equalNavigableMaps(NavigableMap m1,
NavigableMap m2) {
equalNavigableMapsLeaf(m1, m2);
equalNavigableSetsLeaf((NavigableSet) m1.keySet(),
(NavigableSet) m2.keySet());
equalSetsLeaf(m1.keySet(), m2.keySet());
equalNavigableSets(m1.navigableKeySet(),
m2.navigableKeySet());
equalNavigableSets(m1.descendingKeySet(),
@ -836,5 +867,7 @@ public class LockStep {
@SuppressWarnings("unchecked")
static <T> T serialClone(T obj) {
try { return (T) readObject(serializedForm(obj)); }
catch (Exception e) { throw new RuntimeException(e); }}
catch (Error|RuntimeException e) { throw e; }
catch (Throwable e) { throw new RuntimeException(e); }
}
}

154
jdk/test/java/util/Optional/Basic.java
View File

@ -58,36 +58,36 @@ public class Basic {
assertSame(Boolean.FALSE, empty.orElseGet(()-> Boolean.FALSE));
}
@Test(expectedExceptions=NoSuchElementException.class)
public void testEmptyGet() {
Optional<Boolean> empty = Optional.empty();
@Test(expectedExceptions=NoSuchElementException.class)
public void testEmptyGet() {
Optional<Boolean> empty = Optional.empty();
Boolean got = empty.get();
}
Boolean got = empty.get();
}
@Test(expectedExceptions=NullPointerException.class)
public void testEmptyOrElseGetNull() {
Optional<Boolean> empty = Optional.empty();
@Test(expectedExceptions=NullPointerException.class)
public void testEmptyOrElseGetNull() {
Optional<Boolean> empty = Optional.empty();
Boolean got = empty.orElseGet(null);
}
Boolean got = empty.orElseGet(null);
}
@Test(expectedExceptions=NullPointerException.class)
public void testEmptyOrElseThrowNull() throws Throwable {
Optional<Boolean> empty = Optional.empty();
@Test(expectedExceptions=NullPointerException.class)
public void testEmptyOrElseThrowNull() throws Throwable {
Optional<Boolean> empty = Optional.empty();
Boolean got = empty.orElseThrow(null);
}
Boolean got = empty.orElseThrow(null);
}
@Test(expectedExceptions=ObscureException.class)
public void testEmptyOrElseThrow() throws Exception {
Optional<Boolean> empty = Optional.empty();
@Test(expectedExceptions=ObscureException.class)
public void testEmptyOrElseThrow() throws Exception {
Optional<Boolean> empty = Optional.empty();
Boolean got = empty.orElseThrow(ObscureException::new);
}
Boolean got = empty.orElseThrow(ObscureException::new);
}
@Test(groups = "unit")
public void testPresent() {
@Test(groups = "unit")
public void testPresent() {
Optional<Boolean> empty = Optional.empty();
Optional<String> presentEmptyString = Optional.of("");
Optional<Boolean> present = Optional.of(Boolean.TRUE);
@ -116,6 +116,116 @@ public class Basic {
assertSame(Boolean.TRUE, present.<RuntimeException>orElseThrow(ObscureException::new));
}
@Test(groups = "unit")
public void testOfNullable() {
Optional<String> instance = Optional.ofNullable(null);
assertFalse(instance.isPresent());
instance = Optional.ofNullable("Duke");
assertTrue(instance.isPresent());
assertEquals(instance.get(), "Duke");
}
@Test(groups = "unit")
public void testFilter() {
// Null mapper function
Optional<String> empty = Optional.empty();
Optional<String> duke = Optional.of("Duke");
try {
Optional<String> result = empty.filter(null);
fail("Should throw NPE on null mapping function");
} catch (NullPointerException npe) {
// expected
}
Optional<String> result = empty.filter(String::isEmpty);
assertFalse(result.isPresent());
result = duke.filter(String::isEmpty);
assertFalse(result.isPresent());
result = duke.filter(s -> s.startsWith("D"));
assertTrue(result.isPresent());
assertEquals(result.get(), "Duke");
Optional<String> emptyString = Optional.of("");
result = emptyString.filter(String::isEmpty);
assertTrue(result.isPresent());
assertEquals(result.get(), "");
}
@Test(groups = "unit")
public void testMap() {
Optional<String> empty = Optional.empty();
Optional<String> duke = Optional.of("Duke");
// Null mapper function
try {
Optional<Boolean> b = empty.map(null);
fail("Should throw NPE on null mapping function");
} catch (NullPointerException npe) {
// expected
}
// Map an empty value
Optional<Boolean> b = empty.map(String::isEmpty);
assertFalse(b.isPresent());
// Map into null
b = empty.map(n -> null);
assertFalse(b.isPresent());
b = duke.map(s -> null);
assertFalse(b.isPresent());
// Map to value
Optional<Integer> l = duke.map(String::length);
assertEquals(l.get().intValue(), 4);
}
@Test(groups = "unit")
public void testFlatMap() {
Optional<String> empty = Optional.empty();
Optional<String> duke = Optional.of("Duke");
// Null mapper function
try {
Optional<Boolean> b = empty.flatMap(null);
fail("Should throw NPE on null mapping function");
} catch (NullPointerException npe) {
// expected
}
// Map into null
try {
Optional<Boolean> b = duke.flatMap(s -> null);
fail("Should throw NPE when mapper return null");
} catch (NullPointerException npe) {
// expected
}
// Empty won't invoke mapper function
try {
Optional<Boolean> b = empty.flatMap(s -> null);
assertFalse(b.isPresent());
} catch (NullPointerException npe) {
fail("Mapper function should not be invoked");
}
// Map an empty value
Optional<Integer> l = empty.flatMap(s -> Optional.of(s.length()));
assertFalse(l.isPresent());
// Map to value
Optional<Integer> fixture = Optional.of(Integer.MAX_VALUE);
l = duke.flatMap(s -> Optional.of(s.length()));
assertTrue(l.isPresent());
assertEquals(l.get().intValue(), 4);
// Verify same instance
l = duke.flatMap(s -> fixture);
assertSame(l, fixture);
}
private static class ObscureException extends RuntimeException {
}

39
jdk/test/java/util/stream/bootlib/java/util/stream/LambdaTestHelpers.java
View File

@ -360,35 +360,26 @@ public class LambdaTestHelpers {
private static<T> Map<T, Integer> toBoxedMultiset(Iterator<T> it) {
Map<Object, Integer> result = new HashMap<>();
it.forEachRemaining(new OmnivorousConsumer<T>() {
@Override
public void accept(T t) {
add(t);
}
@Override
public void accept(int value) {
add(value);
}
@Override
public void accept(long value) {
add(value);
}
@Override
public void accept(double value) {
add(value);
}
void add(Object o) {
it.forEachRemaining(toBoxingConsumer(o -> {
if (result.containsKey(o))
result.put(o, result.get(o) + 1);
else
result.put(o, 1);
}
}));
});
return (Map<T, Integer>) result;
}
@SuppressWarnings("unchecked")
public static<T> Map<T, Integer> toBoxedMultiset(Spliterator<T> it) {
Map<Object, Integer> result = new HashMap<>();
it.forEachRemaining(toBoxingConsumer(o -> {
if (result.containsKey(o))
result.put(o, result.get(o) + 1);
else
result.put(o, 1);
}));
return (Map<T, Integer>) result;
}

49
jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ConcatOpTest.java Normal file
View File

@ -0,0 +1,49 @@
/*
* 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 org.openjdk.tests.java.util.stream;
import java.util.stream.OpTestCase;
import java.util.stream.StreamTestDataProvider;
import org.testng.annotations.Test;
import java.util.stream.Stream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.DoubleStream;
import java.util.stream.TestData;
import static java.util.stream.LambdaTestHelpers.*;
public class ConcatOpTest extends OpTestCase {
// Sanity to make sure all type of stream source works
@Test(dataProvider = "StreamTestData<Integer>", dataProviderClass = StreamTestDataProvider.class)
public void testOpsSequential(String name, TestData.OfRef<Integer> data) {
exerciseOpsInt(data,
s -> Stream.concat(s, data.stream()),
s -> IntStream.concat(s, data.stream().mapToInt(Integer::intValue)),
s -> LongStream.concat(s, data.stream().mapToLong(Integer::longValue)),
s -> DoubleStream.concat(s, data.stream().mapToDouble(Integer::doubleValue)));
}
}

229
jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/ConcatTest.java Normal file
View File

@ -0,0 +1,229 @@
/*
* 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 org.openjdk.tests.java.util.stream;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Spliterator;
import java.util.TreeSet;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;
import static java.util.stream.LambdaTestHelpers.*;
import static org.testng.Assert.*;
@Test
public class ConcatTest {
private static Object[][] cases;
static {
List<Integer> part1 = Arrays.asList(5, 3, 4, 1, 2, 6, 2, 4);
List<Integer> part2 = Arrays.asList(8, 8, 6, 6, 9, 7, 10, 9);
List<Integer> p1p2 = Arrays.asList(5, 3, 4, 1, 2, 6, 2, 4, 8, 8, 6, 6, 9, 7, 10, 9);
List<Integer> p2p1 = Arrays.asList(8, 8, 6, 6, 9, 7, 10, 9, 5, 3, 4, 1, 2, 6, 2, 4);
List<Integer> empty = new LinkedList<>(); // To be ordered
assertTrue(empty.isEmpty());
LinkedHashSet<Integer> distinctP1 = new LinkedHashSet<>(part1);
LinkedHashSet<Integer> distinctP2 = new LinkedHashSet<>(part2);
TreeSet<Integer> sortedP1 = new TreeSet<>(part1);
TreeSet<Integer> sortedP2 = new TreeSet<>(part2);
cases = new Object[][] {
{ "regular", part1, part2, p1p2 },
{ "reverse regular", part2, part1, p2p1 },
{ "front distinct", distinctP1, part2, Arrays.asList(5, 3, 4, 1, 2, 6, 8, 8, 6, 6, 9, 7, 10, 9) },
{ "back distinct", part1, distinctP2, Arrays.asList(5, 3, 4, 1, 2, 6, 2, 4, 8, 6, 9, 7, 10) },
{ "both distinct", distinctP1, distinctP2, Arrays.asList(5, 3, 4, 1, 2, 6, 8, 6, 9, 7, 10) },
{ "front sorted", sortedP1, part2, Arrays.asList(1, 2, 3, 4, 5, 6, 8, 8, 6, 6, 9, 7, 10, 9) },
{ "back sorted", part1, sortedP2, Arrays.asList(5, 3, 4, 1, 2, 6, 2, 4, 6, 7, 8, 9, 10) },
{ "both sorted", sortedP1, sortedP2, Arrays.asList(1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 10) },
{ "reverse both sorted", sortedP2, sortedP1, Arrays.asList(6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6) },
{ "empty something", empty, part1, part1 },
{ "something empty", part1, empty, part1 },
{ "empty empty", empty, empty, empty }
};
}
@DataProvider(name = "cases")
private static Object[][] getCases() {
return cases;
}
@Factory(dataProvider = "cases")
public static Object[] createTests(String scenario, Collection<Integer> c1, Collection<Integer> c2, Collection<Integer> expected) {
return new Object[] {
new ConcatTest(scenario, c1, c2, expected)
};
}
protected final String scenario;
protected final Collection<Integer> c1;
protected final Collection<Integer> c2;
protected final Collection<Integer> expected;
public ConcatTest(String scenario, Collection<Integer> c1, Collection<Integer> c2, Collection<Integer> expected) {
this.scenario = scenario;
this.c1 = c1;
this.c2 = c2;
this.expected = expected;
// verify prerequisite
Stream<Integer> s1s = c1.stream();
Stream<Integer> s2s = c2.stream();
Stream<Integer> s1p = c1.parallelStream();
Stream<Integer> s2p = c2.parallelStream();
assertTrue(s1p.isParallel());
assertTrue(s2p.isParallel());
assertFalse(s1s.isParallel());
assertFalse(s2s.isParallel());
assertTrue(s1s.spliterator().hasCharacteristics(Spliterator.ORDERED));
assertTrue(s1p.spliterator().hasCharacteristics(Spliterator.ORDERED));
assertTrue(s2s.spliterator().hasCharacteristics(Spliterator.ORDERED));
assertTrue(s2p.spliterator().hasCharacteristics(Spliterator.ORDERED));
}
private <T> void assertConcatContent(Spliterator<T> sp, boolean ordered, Spliterator<T> expected) {
// concat stream cannot guarantee uniqueness
assertFalse(sp.hasCharacteristics(Spliterator.DISTINCT), scenario);
// concat stream cannot guarantee sorted
assertFalse(sp.hasCharacteristics(Spliterator.SORTED), scenario);
// concat stream is ordered if both are ordered
assertEquals(sp.hasCharacteristics(Spliterator.ORDERED), ordered, scenario);
// Verify elements
if (ordered) {
assertEquals(toBoxedList(sp),
toBoxedList(expected),
scenario);
} else {
assertEquals(toBoxedMultiset(sp),
toBoxedMultiset(expected),
scenario);
}
}
private void assertRefConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
Stream<Integer> result = Stream.concat(s1, s2);
assertEquals(result.isParallel(), parallel);
assertConcatContent(result.spliterator(), ordered, expected.spliterator());
}
private void assertIntConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
IntStream result = IntStream.concat(s1.mapToInt(Integer::intValue),
s2.mapToInt(Integer::intValue));
assertEquals(result.isParallel(), parallel);
assertConcatContent(result.spliterator(), ordered,
expected.stream().mapToInt(Integer::intValue).spliterator());
}
private void assertLongConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
LongStream result = LongStream.concat(s1.mapToLong(Integer::longValue),
s2.mapToLong(Integer::longValue));
assertEquals(result.isParallel(), parallel);
assertConcatContent(result.spliterator(), ordered,
expected.stream().mapToLong(Integer::longValue).spliterator());
}
private void assertDoubleConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
DoubleStream result = DoubleStream.concat(s1.mapToDouble(Integer::doubleValue),
s2.mapToDouble(Integer::doubleValue));
assertEquals(result.isParallel(), parallel);
assertConcatContent(result.spliterator(), ordered,
expected.stream().mapToDouble(Integer::doubleValue).spliterator());
}
public void testRefConcat() {
// sequential + sequential -> sequential
assertRefConcat(c1.stream(), c2.stream(), false, true);
// parallel + parallel -> parallel
assertRefConcat(c1.parallelStream(), c2.parallelStream(), true, true);
// sequential + parallel -> parallel
assertRefConcat(c1.stream(), c2.parallelStream(), true, true);
// parallel + sequential -> parallel
assertRefConcat(c1.parallelStream(), c2.stream(), true, true);
// not ordered
assertRefConcat(c1.stream().unordered(), c2.stream(), false, false);
assertRefConcat(c1.stream(), c2.stream().unordered(), false, false);
assertRefConcat(c1.parallelStream().unordered(), c2.stream().unordered(), true, false);
}
public void testIntConcat() {
// sequential + sequential -> sequential
assertIntConcat(c1.stream(), c2.stream(), false, true);
// parallel + parallel -> parallel
assertIntConcat(c1.parallelStream(), c2.parallelStream(), true, true);
// sequential + parallel -> parallel
assertIntConcat(c1.stream(), c2.parallelStream(), true, true);
// parallel + sequential -> parallel
assertIntConcat(c1.parallelStream(), c2.stream(), true, true);
// not ordered
assertIntConcat(c1.stream().unordered(), c2.stream(), false, false);
assertIntConcat(c1.stream(), c2.stream().unordered(), false, false);
assertIntConcat(c1.parallelStream().unordered(), c2.stream().unordered(), true, false);
}
public void testLongConcat() {
// sequential + sequential -> sequential
assertLongConcat(c1.stream(), c2.stream(), false, true);
// parallel + parallel -> parallel
assertLongConcat(c1.parallelStream(), c2.parallelStream(), true, true);
// sequential + parallel -> parallel
assertLongConcat(c1.stream(), c2.parallelStream(), true, true);
// parallel + sequential -> parallel
assertLongConcat(c1.parallelStream(), c2.stream(), true, true);
// not ordered
assertLongConcat(c1.stream().unordered(), c2.stream(), false, false);
assertLongConcat(c1.stream(), c2.stream().unordered(), false, false);
assertLongConcat(c1.parallelStream().unordered(), c2.stream().unordered(), true, false);
}
public void testDoubleConcat() {
// sequential + sequential -> sequential
assertDoubleConcat(c1.stream(), c2.stream(), false, true);
// parallel + parallel -> parallel
assertDoubleConcat(c1.parallelStream(), c2.parallelStream(), true, true);
// sequential + parallel -> parallel
assertDoubleConcat(c1.stream(), c2.parallelStream(), true, true);
// parallel + sequential -> parallel
assertDoubleConcat(c1.parallelStream(), c2.stream(), true, true);
// not ordered
assertDoubleConcat(c1.stream().unordered(), c2.stream(), false, false);
assertDoubleConcat(c1.stream(), c2.stream().unordered(), false, false);
assertDoubleConcat(c1.parallelStream().unordered(), c2.stream().unordered(), true, false);
}
}

222
jdk/test/java/util/stream/test/org/openjdk/tests/java/util/stream/RangeTest.java
View File

@ -226,116 +226,114 @@ public class RangeTest extends OpTestCase {
assertEquals(first, LongStream.iterate(0, i -> i + 1).parallel().filter(i -> i > 10000).findFirst().getAsLong());
}
// Enable when Stream.concat is present and range implementations are
// updated to use that
// private static void assertSizedAndSubSized(Spliterator<?> s) {
// assertTrue(s.hasCharacteristics(Spliterator.SIZED | Spliterator.SUBSIZED));
// }
//
// private static void assertNotSizedAndSubSized(Spliterator<?> s) {
// assertFalse(s.hasCharacteristics(Spliterator.SIZED | Spliterator.SUBSIZED));
// }
//
// public void testLongLongRange() {
// // Test [Long.MIN_VALUE, Long.MAX_VALUE)
// // This will concatenate streams of three ranges
// // [Long.MIN_VALUE, x) [x, 0) [0, Long.MAX_VALUE)
// // where x = Long.divideUnsigned(0 - Long.MIN_VALUE, 2) + 1
// {
// Spliterator.OfLong s = LongStream.range(Long.MIN_VALUE, Long.MAX_VALUE).spliterator();
//
// assertEquals(s.estimateSize(), Long.MAX_VALUE);
// assertNotSizedAndSubSized(s);
//
// Spliterator.OfLong s1 = s.trySplit();
// assertNotSizedAndSubSized(s1);
// assertSizedAndSubSized(s);
//
// Spliterator.OfLong s2 = s1.trySplit();
// assertSizedAndSubSized(s1);
// assertSizedAndSubSized(s2);
//
// assertTrue(s.estimateSize() == Long.MAX_VALUE);
// assertTrue(s1.estimateSize() < Long.MAX_VALUE);
// assertTrue(s2.estimateSize() < Long.MAX_VALUE);
//
// assertEquals(s.estimateSize() + s1.estimateSize() + s2.estimateSize(),
// Long.MAX_VALUE - Long.MIN_VALUE);
// }
//
// long[][] ranges = { {Long.MIN_VALUE, 0}, {-1, Long.MAX_VALUE} };
// for (int i = 0; i < ranges.length; i++) {
// long start = ranges[i][0];
// long end = ranges[i][1];
//
// Spliterator.OfLong s = LongStream.range(start, end).spliterator();
//
// assertEquals(s.estimateSize(), Long.MAX_VALUE);
// assertNotSizedAndSubSized(s);
//
// Spliterator.OfLong s1 = s.trySplit();
// assertSizedAndSubSized(s1);
// assertSizedAndSubSized(s);
//
// assertTrue(s.estimateSize() < Long.MAX_VALUE);
// assertTrue(s1.estimateSize() < Long.MAX_VALUE);
//
// assertEquals(s.estimateSize() + s1.estimateSize(), end - start);
// }
// }
//
// public void testLongLongRangeClosed() {
// // Test [Long.MIN_VALUE, Long.MAX_VALUE]
// // This will concatenate streams of four ranges
// // [Long.MIN_VALUE, x) [x, 0) [0, y) [y, Long.MAX_VALUE]
// // where x = Long.divideUnsigned(0 - Long.MIN_VALUE, 2) + 1
// // y = Long.divideUnsigned(Long.MAX_VALUE, 2) + 1
//
// {
// Spliterator.OfLong s = LongStream.rangeClosed(Long.MIN_VALUE, Long.MAX_VALUE).spliterator();
//
// assertEquals(s.estimateSize(), Long.MAX_VALUE);
// assertNotSizedAndSubSized(s);
//
// Spliterator.OfLong s1 = s.trySplit();
// assertNotSizedAndSubSized(s1);
// assertNotSizedAndSubSized(s);
//
// Spliterator.OfLong s2 = s1.trySplit();
// assertSizedAndSubSized(s1);
// assertSizedAndSubSized(s2);
//
// Spliterator.OfLong s3 = s.trySplit();
// assertSizedAndSubSized(s3);
// assertSizedAndSubSized(s);
//
// assertTrue(s.estimateSize() < Long.MAX_VALUE);
// assertTrue(s3.estimateSize() < Long.MAX_VALUE);
// assertTrue(s1.estimateSize() < Long.MAX_VALUE);
// assertTrue(s2.estimateSize() < Long.MAX_VALUE);
//
// assertEquals(s.estimateSize() + s3.estimateSize() + s1.estimateSize() + s2.estimateSize(),
// Long.MAX_VALUE - Long.MIN_VALUE + 1);
// }
//
// long[][] ranges = { {Long.MIN_VALUE, 0}, {-1, Long.MAX_VALUE} };
// for (int i = 0; i < ranges.length; i++) {
// long start = ranges[i][0];
// long end = ranges[i][1];
//
// Spliterator.OfLong s = LongStream.rangeClosed(start, end).spliterator();
//
// assertEquals(s.estimateSize(), Long.MAX_VALUE);
// assertNotSizedAndSubSized(s);
//
// Spliterator.OfLong s1 = s.trySplit();
// assertSizedAndSubSized(s1);
// assertSizedAndSubSized(s);
//
// assertTrue(s.estimateSize() < Long.MAX_VALUE);
// assertTrue(s1.estimateSize() < Long.MAX_VALUE);
//
// assertEquals(s.estimateSize() + s1.estimateSize(), end - start + 1);
// }
// }
private static void assertSizedAndSubSized(Spliterator<?> s) {
assertTrue(s.hasCharacteristics(Spliterator.SIZED | Spliterator.SUBSIZED));
}
private static void assertNotSizedAndSubSized(Spliterator<?> s) {
assertFalse(s.hasCharacteristics(Spliterator.SIZED | Spliterator.SUBSIZED));
}
public void testLongLongRange() {
// Test [Long.MIN_VALUE, Long.MAX_VALUE)
// This will concatenate streams of three ranges
// [Long.MIN_VALUE, x) [x, 0) [0, Long.MAX_VALUE)
// where x = Long.divideUnsigned(0 - Long.MIN_VALUE, 2) + 1
{
Spliterator.OfLong s = LongStream.range(Long.MIN_VALUE, Long.MAX_VALUE).spliterator();
assertEquals(s.estimateSize(), Long.MAX_VALUE);
assertNotSizedAndSubSized(s);
Spliterator.OfLong s1 = s.trySplit();
assertNotSizedAndSubSized(s1);
assertSizedAndSubSized(s);
Spliterator.OfLong s2 = s1.trySplit();
assertSizedAndSubSized(s1);
assertSizedAndSubSized(s2);
assertTrue(s.estimateSize() == Long.MAX_VALUE);
assertTrue(s1.estimateSize() < Long.MAX_VALUE);
assertTrue(s2.estimateSize() < Long.MAX_VALUE);
assertEquals(s.estimateSize() + s1.estimateSize() + s2.estimateSize(),
Long.MAX_VALUE - Long.MIN_VALUE);
}
long[][] ranges = { {Long.MIN_VALUE, 0}, {-1, Long.MAX_VALUE} };
for (int i = 0; i < ranges.length; i++) {
long start = ranges[i][0];
long end = ranges[i][1];
Spliterator.OfLong s = LongStream.range(start, end).spliterator();
assertEquals(s.estimateSize(), Long.MAX_VALUE);
assertNotSizedAndSubSized(s);
Spliterator.OfLong s1 = s.trySplit();
assertSizedAndSubSized(s1);
assertSizedAndSubSized(s);
assertTrue(s.estimateSize() < Long.MAX_VALUE);
assertTrue(s1.estimateSize() < Long.MAX_VALUE);
assertEquals(s.estimateSize() + s1.estimateSize(), end - start);
}
}
public void testLongLongRangeClosed() {
// Test [Long.MIN_VALUE, Long.MAX_VALUE]
// This will concatenate streams of four ranges
// [Long.MIN_VALUE, x) [x, 0) [0, y) [y, Long.MAX_VALUE]
// where x = Long.divideUnsigned(0 - Long.MIN_VALUE, 2) + 1
// y = Long.divideUnsigned(Long.MAX_VALUE, 2) + 1
{
Spliterator.OfLong s = LongStream.rangeClosed(Long.MIN_VALUE, Long.MAX_VALUE).spliterator();
assertEquals(s.estimateSize(), Long.MAX_VALUE);
assertNotSizedAndSubSized(s);
Spliterator.OfLong s1 = s.trySplit();
assertNotSizedAndSubSized(s1);
assertNotSizedAndSubSized(s);
Spliterator.OfLong s2 = s1.trySplit();
assertSizedAndSubSized(s1);
assertSizedAndSubSized(s2);
Spliterator.OfLong s3 = s.trySplit();
assertSizedAndSubSized(s3);
assertSizedAndSubSized(s);
assertTrue(s.estimateSize() < Long.MAX_VALUE);
assertTrue(s3.estimateSize() < Long.MAX_VALUE);
assertTrue(s1.estimateSize() < Long.MAX_VALUE);
assertTrue(s2.estimateSize() < Long.MAX_VALUE);
assertEquals(s.estimateSize() + s3.estimateSize() + s1.estimateSize() + s2.estimateSize(),
Long.MAX_VALUE - Long.MIN_VALUE + 1);
}
long[][] ranges = { {Long.MIN_VALUE, 0}, {-1, Long.MAX_VALUE} };
for (int i = 0; i < ranges.length; i++) {
long start = ranges[i][0];
long end = ranges[i][1];
Spliterator.OfLong s = LongStream.rangeClosed(start, end).spliterator();
assertEquals(s.estimateSize(), Long.MAX_VALUE);
assertNotSizedAndSubSized(s);
Spliterator.OfLong s1 = s.trySplit();
assertSizedAndSubSized(s1);
assertSizedAndSubSized(s);
assertTrue(s.estimateSize() < Long.MAX_VALUE);
assertTrue(s1.estimateSize() < Long.MAX_VALUE);
assertEquals(s.estimateSize() + s1.estimateSize(), end - start + 1);
}
}
}