Skip to content

D
dragonwell8_jdk

openanolis / dragonwell8_jdk

通知 4
Star 2
Fork 0
D
dragonwell8_jdk
提交 d11eedbf 编写于 作者: M mduigou
浏览文件
操作

7129185: Add Collections.{checked|empty|unmodifiable}Navigable{Map|Set} 

Reviewed-by: dmocek, martin, smarks
上级 e5c1052c
隐藏空白更改
内联 并排
Showing with 1982 addition and 704 deletion
src/share/classes/java/util/AbstractMap.java
浏览文件 @ d11eedbf
...@@ -543,6 +543,8 @@ public abstract class AbstractMap<K,V> implements Map<K,V> { ...@@ -543,6 +543,8 @@ public abstract class AbstractMap<K,V> implements Map<K,V> {
/** /**
* Utility method for SimpleEntry and SimpleImmutableEntry. * Utility method for SimpleEntry and SimpleImmutableEntry.
* Test for equality, checking for nulls. * 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) { private static boolean eq(Object o1, Object o2) {
return o1 == null ? o2 == null : o1.equals(o2); return o1 == null ? o2 == null : o1.equals(o2);
......
src/share/classes/java/util/Collections.java
浏览文件 @ d11eedbf
...@@ -27,6 +27,7 @@ package java.util; ...@@ -27,6 +27,7 @@ package java.util;
import java.io.Serializable; import java.io.Serializable;
import java.io.ObjectOutputStream; import java.io.ObjectOutputStream;
import java.io.IOException; import java.io.IOException;
import java.io.InvalidObjectException;
import java.lang.reflect.Array; import java.lang.reflect.Array;
import java.util.function.BiConsumer; import java.util.function.BiConsumer;
import java.util.function.BiFunction; import java.util.function.BiFunction;
...@@ -138,7 +139,7 @@ public class Collections { ...@@ -138,7 +139,7 @@ public class Collections {
* *
* <p>The implementation was adapted from Tim Peters's list sort for Python * <p>The implementation was adapted from Tim Peters's list sort for Python
* (<a href="http://svn.python.org/projects/python/trunk/Objects/listsort.txt"> * (<a href="http://svn.python.org/projects/python/trunk/Objects/listsort.txt">
* TimSort</a>). It uses techiques from Peter McIlroy's "Optimistic * TimSort</a>). It uses techniques from Peter McIlroy's "Optimistic
* Sorting and Information Theoretic Complexity", in Proceedings of the * Sorting and Information Theoretic Complexity", in Proceedings of the
* Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 467-474, * Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 467-474,
* January 1993. * January 1993.
...@@ -199,7 +200,7 @@ public class Collections { ...@@ -199,7 +200,7 @@ public class Collections {
* *
* <p>The implementation was adapted from Tim Peters's list sort for Python * <p>The implementation was adapted from Tim Peters's list sort for Python
* (<a href="http://svn.python.org/projects/python/trunk/Objects/listsort.txt"> * (<a href="http://svn.python.org/projects/python/trunk/Objects/listsort.txt">
* TimSort</a>). It uses techiques from Peter McIlroy's "Optimistic * TimSort</a>). It uses techniques from Peter McIlroy's "Optimistic
* Sorting and Information Theoretic Complexity", in Proceedings of the * Sorting and Information Theoretic Complexity", in Proceedings of the
* Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 467-474, * Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 467-474,
* January 1993. * January 1993.
...@@ -1213,6 +1214,94 @@ public class Collections { ...@@ -1213,6 +1214,94 @@ public class Collections {
public E last() {return ss.last();} public E last() {return ss.last();}
} }
/**
* Returns an unmodifiable view of the specified navigable set. This method
* allows modules to provide users with "read-only" access to internal
* navigable sets. Query operations on the returned navigable set "read
* through" to the specified navigable set. Attempts to modify the returned
* navigable set, whether direct, via its iterator, or via its
* {@code subSet}, {@code headSet}, or {@code tailSet} views, result in
* an {@code UnsupportedOperationException}.<p>
*
* The returned navigable set will be serializable if the specified
* navigable set is serializable.
*
* @param s the navigable set for which an unmodifiable view is to be
* returned
* @return an unmodifiable view of the specified navigable set
* @since 1.8
*/
public static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s) {
return new UnmodifiableNavigableSet<>(s);
}
/**
* Wraps a navigable set and disables all of the mutative operations.
*
* @param <E> type of elements
* @serial include
*/
static class UnmodifiableNavigableSet<E>
extends UnmodifiableSortedSet<E>
implements NavigableSet<E>, Serializable {
private static final long serialVersionUID = -6027448201786391929L;
/**
* A singleton empty unmodifiable navigable set used for
* {@link #emptyNavigableSet()}.
*
* @param <E> type of elements, if there were any, and bounds
*/
private static class EmptyNavigableSet<E> extends UnmodifiableNavigableSet<E>
implements Serializable {
private static final long serialVersionUID = -6291252904449939134L;
public EmptyNavigableSet() {
super(new TreeSet<E>());
}
private Object readResolve() { return EMPTY_NAVIGABLE_SET; }
}
@SuppressWarnings("rawtypes")
private static final NavigableSet<?> EMPTY_NAVIGABLE_SET =
new EmptyNavigableSet<>();
/**
* The instance we are protecting.
*/
private final NavigableSet<E> ns;
UnmodifiableNavigableSet(NavigableSet<E> s) {super(s); ns = s;}
public E lower(E e) { return ns.lower(e); }
public E floor(E e) { return ns.floor(e); }
public E ceiling(E e) { return ns.ceiling(e); }
public E higher(E e) { return ns.higher(e); }
public E pollFirst() { throw new UnsupportedOperationException(); }
public E pollLast() { throw new UnsupportedOperationException(); }
public NavigableSet<E> descendingSet()
{ return new UnmodifiableNavigableSet<>(ns.descendingSet()); }
public Iterator<E> descendingIterator()
{ return descendingSet().iterator(); }
public NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
return new UnmodifiableNavigableSet<>(
ns.subSet(fromElement, fromInclusive, toElement, toInclusive));
}
public NavigableSet<E> headSet(E toElement, boolean inclusive) {
return new UnmodifiableNavigableSet<>(
ns.headSet(toElement, inclusive));
}
public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
return new UnmodifiableNavigableSet<>(
ns.tailSet(fromElement, inclusive));
}
}
/** /**
* Returns an unmodifiable view of the specified list. This method allows * Returns an unmodifiable view of the specified list. This method allows
* modules to provide users with "read-only" access to internal * modules to provide users with "read-only" access to internal
...@@ -1240,6 +1329,7 @@ public class Collections { ...@@ -1240,6 +1329,7 @@ public class Collections {
static class UnmodifiableList<E> extends UnmodifiableCollection<E> static class UnmodifiableList<E> extends UnmodifiableCollection<E>
implements List<E> { implements List<E> {
private static final long serialVersionUID = -283967356065247728L; private static final long serialVersionUID = -283967356065247728L;
final List<? extends E> list; final List<? extends E> list;
UnmodifiableList(List<? extends E> list) { UnmodifiableList(List<? extends E> list) {
...@@ -1682,7 +1772,8 @@ public class Collections { ...@@ -1682,7 +1772,8 @@ public class Collections {
private static class UnmodifiableEntry<K,V> implements Map.Entry<K,V> { private static class UnmodifiableEntry<K,V> implements Map.Entry<K,V> {
private Map.Entry<? extends K, ? extends V> e; private Map.Entry<? extends K, ? extends V> e;
UnmodifiableEntry(Map.Entry<? extends K, ? extends V> e) {this.e = e;} UnmodifiableEntry(Map.Entry<? extends K, ? extends V> e)
{this.e = Objects.requireNonNull(e);}
public K getKey() {return e.getKey();} public K getKey() {return e.getKey();}
public V getValue() {return e.getValue();} public V getValue() {return e.getValue();}
...@@ -1734,24 +1825,151 @@ public class Collections { ...@@ -1734,24 +1825,151 @@ public class Collections {
private final SortedMap<K, ? extends V> sm; private final SortedMap<K, ? extends V> sm;
UnmodifiableSortedMap(SortedMap<K, ? extends V> m) {super(m); sm = m;} UnmodifiableSortedMap(SortedMap<K, ? extends V> m) {super(m); sm = m; }
public Comparator<? super K> comparator() { return sm.comparator(); }
public SortedMap<K,V> subMap(K fromKey, K toKey)
{ return new UnmodifiableSortedMap<>(sm.subMap(fromKey, toKey)); }
public SortedMap<K,V> headMap(K toKey)
{ return new UnmodifiableSortedMap<>(sm.headMap(toKey)); }
public SortedMap<K,V> tailMap(K fromKey)
{ return new UnmodifiableSortedMap<>(sm.tailMap(fromKey)); }
public K firstKey() { return sm.firstKey(); }
public K lastKey() { return sm.lastKey(); }
}
public Comparator<? super K> comparator() {return sm.comparator();} /**
* Returns an unmodifiable view of the specified navigable map. This method
* allows modules to provide users with "read-only" access to internal
* navigable maps. Query operations on the returned navigable map "read
* through" to the specified navigable map. Attempts to modify the returned
* navigable map, whether direct, via its collection views, or via its
* {@code subMap}, {@code headMap}, or {@code tailMap} views, result in
* an {@code UnsupportedOperationException}.<p>
*
* The returned navigable map will be serializable if the specified
* navigable map is serializable.
*
* @param m the navigable map for which an unmodifiable view is to be
* returned
* @return an unmodifiable view of the specified navigable map
* @since 1.8
*/
public static <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K, ? extends V> m) {
return new UnmodifiableNavigableMap<>(m);
}
public SortedMap<K,V> subMap(K fromKey, K toKey) { /**
return new UnmodifiableSortedMap<>(sm.subMap(fromKey, toKey)); * @serial include
*/
static class UnmodifiableNavigableMap<K,V>
extends UnmodifiableSortedMap<K,V>
implements NavigableMap<K,V>, Serializable {
private static final long serialVersionUID = -4858195264774772197L;
/**
* A class for the {@link EMPTY_NAVIGABLE_MAP} which needs readResolve
* to preserve singleton property.
*
* @param <K> type of keys, if there were any, and of bounds
* @param <V> type of values, if there were any
*/
private static class EmptyNavigableMap<K,V> extends UnmodifiableNavigableMap<K,V>
implements Serializable {
private static final long serialVersionUID = -2239321462712562324L;
EmptyNavigableMap() { super(new TreeMap()); }
@Override
public NavigableSet<K> navigableKeySet()
{ return emptyNavigableSet(); }
private Object readResolve() { return EMPTY_NAVIGABLE_MAP; }
} }
public SortedMap<K,V> headMap(K toKey) {
return new UnmodifiableSortedMap<>(sm.headMap(toKey)); /**
* Singleton for {@link emptyNavigableMap()} which is also immutable.
*/
private static final EmptyNavigableMap<?,?> EMPTY_NAVIGABLE_MAP =
new EmptyNavigableMap<>();
/**
* The instance we wrap and protect.
*/
private final NavigableMap<K, ? extends V> nm;
UnmodifiableNavigableMap(NavigableMap<K, ? extends V> m)
{super(m); nm = m;}
public K lowerKey(K key) { return nm.lowerKey(key); }
public K floorKey(K key) { return nm.floorKey(key); }
public K ceilingKey(K key) { return nm.ceilingKey(key); }
public K higherKey(K key) { return nm.higherKey(key); }
public Entry<K, V> lowerEntry(K key) {
Entry<K,V> lower = (Entry<K, V>) nm.lowerEntry(key);
return (null != lower)
? new UnmodifiableEntrySet.UnmodifiableEntry(lower)
: null;
} }
public SortedMap<K,V> tailMap(K fromKey) {
return new UnmodifiableSortedMap<>(sm.tailMap(fromKey)); public Entry<K, V> floorEntry(K key) {
Entry<K,V> floor = (Entry<K, V>) nm.floorEntry(key);
return (null != floor)
? new UnmodifiableEntrySet.UnmodifiableEntry(floor)
: null;
} }
public K firstKey() {return sm.firstKey();} public Entry<K, V> ceilingEntry(K key) {
public K lastKey() {return sm.lastKey();} Entry<K,V> ceiling = (Entry<K, V>) nm.ceilingEntry(key);
} return (null != ceiling)
? new UnmodifiableEntrySet.UnmodifiableEntry(ceiling)
: null;
}
public Entry<K, V> higherEntry(K key) {
Entry<K,V> higher = (Entry<K, V>) nm.higherEntry(key);
return (null != higher)
? new UnmodifiableEntrySet.UnmodifiableEntry(higher)
: null;
}
public Entry<K, V> firstEntry() {
Entry<K,V> first = (Entry<K, V>) nm.firstEntry();
return (null != first)
? new UnmodifiableEntrySet.UnmodifiableEntry(first)
: null;
}
public Entry<K, V> lastEntry() {
Entry<K,V> last = (Entry<K, V>) nm.lastEntry();
return (null != last)
? new UnmodifiableEntrySet.UnmodifiableEntry(last)
: null;
}
public Entry<K, V> pollFirstEntry()
{ throw new UnsupportedOperationException(); }
public Entry<K, V> pollLastEntry()
{ throw new UnsupportedOperationException(); }
public NavigableMap<K, V> descendingMap()
{ return unmodifiableNavigableMap(nm.descendingMap()); }
public NavigableSet<K> navigableKeySet()
{ return unmodifiableNavigableSet(nm.navigableKeySet()); }
public NavigableSet<K> descendingKeySet()
{ return unmodifiableNavigableSet(nm.descendingKeySet()); }
public NavigableMap<K, V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
return unmodifiableNavigableMap(
nm.subMap(fromKey, fromInclusive, toKey, toInclusive));
}
public NavigableMap<K, V> headMap(K toKey, boolean inclusive)
{ return unmodifiableNavigableMap(nm.headMap(toKey, inclusive)); }
public NavigableMap<K, V> tailMap(K fromKey, boolean inclusive)
{ return unmodifiableNavigableMap(nm.tailMap(fromKey, inclusive)); }
}
// Synch Wrappers // Synch Wrappers
...@@ -1805,14 +2023,13 @@ public class Collections { ...@@ -1805,14 +2023,13 @@ public class Collections {
final Object mutex; // Object on which to synchronize final Object mutex; // Object on which to synchronize
SynchronizedCollection(Collection<E> c) { SynchronizedCollection(Collection<E> c) {
if (c==null) this.c = Objects.requireNonNull(c);
throw new NullPointerException();
this.c = c;
mutex = this; mutex = this;
} }
SynchronizedCollection(Collection<E> c, Object mutex) { SynchronizedCollection(Collection<E> c, Object mutex) {
this.c = c; this.c = Objects.requireNonNull(c);
this.mutex = mutex; this.mutex = Objects.requireNonNull(mutex);
} }
public int size() { public int size() {
...@@ -2026,6 +2243,120 @@ public class Collections { ...@@ -2026,6 +2243,120 @@ public class Collections {
} }
} }
/**
* Returns a synchronized (thread-safe) navigable set backed by the
* specified navigable set. In order to guarantee serial access, it is
* critical that <strong>all</strong> access to the backing navigable set is
* accomplished through the returned navigable set (or its views).<p>
*
* It is imperative that the user manually synchronize on the returned
* navigable set when iterating over it or any of its {@code subSet},
* {@code headSet}, or {@code tailSet} views.
* <pre>
* NavigableSet s = Collections.synchronizedNavigableSet(new TreeSet());
* ...
* synchronized (s) {
* Iterator i = s.iterator(); // Must be in the synchronized block
* while (i.hasNext())
* foo(i.next());
* }
* </pre>
* or:
* <pre>
* NavigableSet s = Collections.synchronizedNavigableSet(new TreeSet());
* NavigableSet s2 = s.headSet(foo, true);
* ...
* synchronized (s) { // Note: s, not s2!!!
* Iterator i = s2.iterator(); // Must be in the synchronized block
* while (i.hasNext())
* foo(i.next());
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>The returned navigable set will be serializable if the specified
* navigable set is serializable.
*
* @param s the navigable set to be "wrapped" in a synchronized navigable
* set
* @return a synchronized view of the specified navigable set
* @since 1.8
*/
public static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s) {
return new SynchronizedNavigableSet<>(s);
}
/**
* @serial include
*/
static class SynchronizedNavigableSet<E>
extends SynchronizedSortedSet<E>
implements NavigableSet<E>
{
private static final long serialVersionUID = -5505529816273629798L;
private final NavigableSet<E> ns;
SynchronizedNavigableSet(NavigableSet<E> s) {
super(s);
ns = s;
}
SynchronizedNavigableSet(NavigableSet<E> s, Object mutex) {
super(s, mutex);
ns = s;
}
public E lower(E e) { synchronized (mutex) {return ns.lower(e);} }
public E floor(E e) { synchronized (mutex) {return ns.floor(e);} }
public E ceiling(E e) { synchronized (mutex) {return ns.ceiling(e);} }
public E higher(E e) { synchronized (mutex) {return ns.higher(e);} }
public E pollFirst() { synchronized (mutex) {return ns.pollFirst();} }
public E pollLast() { synchronized (mutex) {return ns.pollLast();} }
public NavigableSet<E> descendingSet() {
synchronized (mutex) {
return new SynchronizedNavigableSet<>(ns.descendingSet(), mutex);
}
}
public Iterator<E> descendingIterator()
{ synchronized (mutex) { return descendingSet().iterator(); } }
public NavigableSet<E> subSet(E fromElement, E toElement) {
synchronized (mutex) {
return new SynchronizedNavigableSet<>(ns.subSet(fromElement, true, toElement, false), mutex);
}
}
public NavigableSet<E> headSet(E toElement) {
synchronized (mutex) {
return new SynchronizedNavigableSet<>(ns.headSet(toElement, false), mutex);
}
}
public NavigableSet<E> tailSet(E fromElement) {
synchronized (mutex) {
return new SynchronizedNavigableSet(ns.tailSet(fromElement, true), mutex);
}
}
public NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
synchronized (mutex) {
return new SynchronizedNavigableSet<>(ns.subSet(fromElement, fromInclusive, toElement, toInclusive), mutex);
}
}
public NavigableSet<E> headSet(E toElement, boolean inclusive) {
synchronized (mutex) {
return new SynchronizedNavigableSet<>(ns.headSet(toElement, inclusive), mutex);
}
}
public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
synchronized (mutex) {
return new SynchronizedNavigableSet<>(ns.tailSet(fromElement, inclusive));
}
}
}
/** /**
* Returns a synchronized (thread-safe) list backed by the specified * Returns a synchronized (thread-safe) list backed by the specified
* list. In order to guarantee serial access, it is critical that * list. In order to guarantee serial access, it is critical that
...@@ -2235,9 +2566,7 @@ public class Collections { ...@@ -2235,9 +2566,7 @@ public class Collections {
final Object mutex; // Object on which to synchronize final Object mutex; // Object on which to synchronize
SynchronizedMap(Map<K,V> m) { SynchronizedMap(Map<K,V> m) {
if (m==null) this.m = Objects.requireNonNull(m);
throw new NullPointerException();
this.m = m;
mutex = this; mutex = this;
} }
...@@ -2416,7 +2745,6 @@ public class Collections { ...@@ -2416,7 +2745,6 @@ public class Collections {
return new SynchronizedSortedMap<>(m); return new SynchronizedSortedMap<>(m);
} }
/** /**
* @serial include * @serial include
*/ */
...@@ -2466,6 +2794,164 @@ public class Collections { ...@@ -2466,6 +2794,164 @@ public class Collections {
} }
} }
/**
* Returns a synchronized (thread-safe) navigable map backed by the
* specified navigable map. In order to guarantee serial access, it is
* critical that <strong>all</strong> access to the backing navigable map is
* accomplished through the returned navigable map (or its views).<p>
*
* It is imperative that the user manually synchronize on the returned
* navigable map when iterating over any of its collection views, or the
* collections views of any of its {@code subMap}, {@code headMap} or
* {@code tailMap} views.
* <pre>
* NavigableMap m = Collections.synchronizedNavigableMap(new TreeMap());
* ...
* Set s = m.keySet(); // Needn't be in synchronized block
* ...
* synchronized (m) { // Synchronizing on m, not s!
* Iterator i = s.iterator(); // Must be in synchronized block
* while (i.hasNext())
* foo(i.next());
* }
* </pre>
* or:
* <pre>
* NavigableMap m = Collections.synchronizedNavigableMap(new TreeMap());
* NavigableMap m2 = m.subMap(foo, true, bar, false);
* ...
* Set s2 = m2.keySet(); // Needn't be in synchronized block
* ...
* synchronized (m) { // Synchronizing on m, not m2 or s2!
* Iterator i = s.iterator(); // Must be in synchronized block
* while (i.hasNext())
* foo(i.next());
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>The returned navigable map will be serializable if the specified
* navigable map is serializable.
*
* @param m the navigable map to be "wrapped" in a synchronized navigable
* map
* @return a synchronized view of the specified navigable map.
* @since 1.8
*/
public static <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m) {
return new SynchronizedNavigableMap<>(m);
}
/**
* A synchronized NavigableMap.
*
* @serial include
*/
static class SynchronizedNavigableMap<K,V>
extends SynchronizedSortedMap<K,V>
implements NavigableMap<K,V>
{
private static final long serialVersionUID = 699392247599746807L;
private final NavigableMap<K,V> nm;
SynchronizedNavigableMap(NavigableMap<K,V> m) {
super(m);
nm = m;
}
SynchronizedNavigableMap(NavigableMap<K,V> m, Object mutex) {
super(m, mutex);
nm = m;
}
public Entry<K, V> lowerEntry(K key)
{ synchronized (mutex) { return nm.lowerEntry(key); } }
public K lowerKey(K key)
{ synchronized (mutex) { return nm.lowerKey(key); } }
public Entry<K, V> floorEntry(K key)
{ synchronized (mutex) { return nm.floorEntry(key); } }
public K floorKey(K key)
{ synchronized (mutex) { return nm.floorKey(key); } }
public Entry<K, V> ceilingEntry(K key)
{ synchronized (mutex) { return nm.ceilingEntry(key); } }
public K ceilingKey(K key)
{ synchronized (mutex) { return nm.ceilingKey(key); } }
public Entry<K, V> higherEntry(K key)
{ synchronized (mutex) { return nm.higherEntry(key); } }
public K higherKey(K key)
{ synchronized (mutex) { return nm.higherKey(key); } }
public Entry<K, V> firstEntry()
{ synchronized (mutex) { return nm.firstEntry(); } }
public Entry<K, V> lastEntry()
{ synchronized (mutex) { return nm.lastEntry(); } }
public Entry<K, V> pollFirstEntry()
{ synchronized (mutex) { return nm.pollFirstEntry(); } }
public Entry<K, V> pollLastEntry()
{ synchronized (mutex) { return nm.pollLastEntry(); } }
public NavigableMap<K, V> descendingMap() {
synchronized (mutex) {
return
new SynchronizedNavigableMap(nm.descendingMap(), mutex);
}
}
public NavigableSet<K> keySet() {
return navigableKeySet();
}
public NavigableSet<K> navigableKeySet() {
synchronized (mutex) {
return new SynchronizedNavigableSet(nm.navigableKeySet(), mutex);
}
}
public NavigableSet<K> descendingKeySet() {
synchronized (mutex) {
return new SynchronizedNavigableSet(nm.descendingKeySet(), mutex);
}
}
public SortedMap<K,V> subMap(K fromKey, K toKey) {
synchronized (mutex) {
return new SynchronizedNavigableMap<>(
nm.subMap(fromKey, true, toKey, false), mutex);
}
}
public SortedMap<K,V> headMap(K toKey) {
synchronized (mutex) {
return new SynchronizedNavigableMap<>(nm.headMap(toKey, false), mutex);
}
}
public SortedMap<K,V> tailMap(K fromKey) {
synchronized (mutex) {
return new SynchronizedNavigableMap<>(nm.tailMap(fromKey, true),mutex);
}
}
public NavigableMap<K, V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
synchronized (mutex) {
return new SynchronizedNavigableMap(
nm.subMap(fromKey, fromInclusive, toKey, toInclusive), mutex);
}
}
public NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
synchronized (mutex) {
return new SynchronizedNavigableMap(
nm.headMap(toKey, inclusive), mutex);
}
}
public NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
synchronized (mutex) {
return new SynchronizedNavigableMap(
nm.tailMap(fromKey, inclusive), mutex);
}
}
}
// Dynamically typesafe collection wrappers // Dynamically typesafe collection wrappers
/** /**
...@@ -2497,12 +2983,12 @@ public class Collections { ...@@ -2497,12 +2983,12 @@ public class Collections {
* program to wrap the collection with a dynamically typesafe view. * program to wrap the collection with a dynamically typesafe view.
* For example, this declaration: * For example, this declaration:
* <pre> {@code * <pre> {@code
* Collection<String> c = new HashSet<String>(); * Collection<String> c = new HashSet<>();
* }</pre> * }</pre>
* may be replaced temporarily by this one: * may be replaced temporarily by this one:
* <pre> {@code * <pre> {@code
* Collection<String> c = Collections.checkedCollection( * Collection<String> c = Collections.checkedCollection(
* new HashSet<String>(), String.class); * new HashSet<>(), String.class);
* }</pre> * }</pre>
* Running the program again will cause it to fail at the point where * Running the program again will cause it to fail at the point where
* an incorrectly typed element is inserted into the collection, clearly * an incorrectly typed element is inserted into the collection, clearly
...@@ -2788,6 +3274,7 @@ public class Collections { ...@@ -2788,6 +3274,7 @@ public class Collections {
implements SortedSet<E>, Serializable implements SortedSet<E>, Serializable
{ {
private static final long serialVersionUID = 1599911165492914959L; private static final long serialVersionUID = 1599911165492914959L;
private final SortedSet<E> ss; private final SortedSet<E> ss;
CheckedSortedSet(SortedSet<E> s, Class<E> type) { CheckedSortedSet(SortedSet<E> s, Class<E> type) {
...@@ -2810,6 +3297,87 @@ public class Collections { ...@@ -2810,6 +3297,87 @@ public class Collections {
} }
} }
/**
* Returns a dynamically typesafe view of the specified navigable set.
* Any attempt to insert an element of the wrong type will result in an
* immediate {@link ClassCastException}. Assuming a navigable set
* contains no incorrectly typed elements prior to the time a
* dynamically typesafe view is generated, and that all subsequent
* access to the navigable set takes place through the view, it is
* <em>guaranteed</em> that the navigable set cannot contain an incorrectly
* typed element.
*
* <p>A discussion of the use of dynamically typesafe views may be
* found in the documentation for the {@link #checkedCollection
* checkedCollection} method.
*
* <p>The returned navigable set will be serializable if the specified
* navigable set is serializable.
*
* <p>Since {@code null} is considered to be a value of any reference
* type, the returned navigable set permits insertion of null elements
* whenever the backing sorted set does.
*
* @param s the navigable set for which a dynamically typesafe view is to be
* returned
* @param type the type of element that {@code s} is permitted to hold
* @return a dynamically typesafe view of the specified navigable set
* @since 1.8
*/
public static <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s,
Class<E> type) {
return new CheckedNavigableSet<>(s, type);
}
/**
* @serial include
*/
static class CheckedNavigableSet<E> extends CheckedSortedSet<E>
implements NavigableSet<E>, Serializable
{
private static final long serialVersionUID = -5429120189805438922L;
private final NavigableSet<E> ns;
CheckedNavigableSet(NavigableSet<E> s, Class<E> type) {
super(s, type);
ns = s;
}
public E lower(E e) { return ns.lower(e); }
public E floor(E e) { return ns.floor(e); }
public E ceiling(E e) { return ns.ceiling(e); }
public E higher(E e) { return ns.higher(e); }
public E pollFirst() { return ns.pollFirst(); }
public E pollLast() {return ns.pollLast(); }
public NavigableSet<E> descendingSet()
{ return checkedNavigableSet(ns.descendingSet(), type); }
public Iterator<E> descendingIterator()
{return checkedNavigableSet(ns.descendingSet(), type).iterator(); }
public NavigableSet<E> subSet(E fromElement, E toElement) {
return checkedNavigableSet(ns.subSet(fromElement, true, toElement, false), type);
}
public NavigableSet<E> headSet(E toElement) {
return checkedNavigableSet(ns.headSet(toElement, false), type);
}
public NavigableSet<E> tailSet(E fromElement) {
return checkedNavigableSet(ns.tailSet(fromElement, true), type);
}
public NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
return checkedNavigableSet(ns.subSet(fromElement, fromInclusive, toElement, toInclusive), type);
}
public NavigableSet<E> headSet(E toElement, boolean inclusive) {
return checkedNavigableSet(ns.headSet(toElement, inclusive), type);
}
public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
return checkedNavigableSet(ns.tailSet(fromElement, inclusive), type);
}
}
/** /**
* Returns a dynamically typesafe view of the specified list. * Returns a dynamically typesafe view of the specified list.
* Any attempt to insert an element of the wrong type will result in * Any attempt to insert an element of the wrong type will result in
...@@ -3022,11 +3590,9 @@ public class Collections { ...@@ -3022,11 +3590,9 @@ public class Collections {
} }
CheckedMap(Map<K, V> m, Class<K> keyType, Class<V> valueType) { CheckedMap(Map<K, V> m, Class<K> keyType, Class<V> valueType) {
if (m == null || keyType == null || valueType == null) this.m = Objects.requireNonNull(m);
throw new NullPointerException(); this.keyType = Objects.requireNonNull(keyType);
this.m = m; this.valueType = Objects.requireNonNull(valueType);
this.keyType = keyType;
this.valueType = valueType;
} }
public int size() { return m.size(); } public int size() { return m.size(); }
...@@ -3303,8 +3869,8 @@ public class Collections { ...@@ -3303,8 +3869,8 @@ public class Collections {
private final Class<T> valueType; private final Class<T> valueType;
CheckedEntry(Map.Entry<K, V> e, Class<T> valueType) { CheckedEntry(Map.Entry<K, V> e, Class<T> valueType) {
this.e = e; this.e = Objects.requireNonNull(e);
this.valueType = valueType; this.valueType = Objects.requireNonNull(valueType);
} }
public K getKey() { return e.getKey(); } public K getKey() { return e.getKey(); }
...@@ -3407,6 +3973,177 @@ public class Collections { ...@@ -3407,6 +3973,177 @@ public class Collections {
} }
} }
/**
* Returns a dynamically typesafe view of the specified navigable map.
* Any attempt to insert a mapping whose key or value have the wrong
* type will result in an immediate {@link ClassCastException}.
* Similarly, any attempt to modify the value currently associated with
* a key will result in an immediate {@link ClassCastException},
* whether the modification is attempted directly through the map
* itself, or through a {@link Map.Entry} instance obtained from the
* map's {@link Map#entrySet() entry set} view.
*
* <p>Assuming a map contains no incorrectly typed keys or values
* prior to the time a dynamically typesafe view is generated, and
* that all subsequent access to the map takes place through the view
* (or one of its collection views), it is <em>guaranteed</em> that the
* map cannot contain an incorrectly typed key or value.
*
* <p>A discussion of the use of dynamically typesafe views may be
* found in the documentation for the {@link #checkedCollection
* checkedCollection} method.
*
* <p>The returned map will be serializable if the specified map is
* serializable.
*
* <p>Since {@code null} is considered to be a value of any reference
* type, the returned map permits insertion of null keys or values
* whenever the backing map does.
*
* @param <K> type of map keys
* @param <V> type of map values
* @param m the map for which a dynamically typesafe view is to be
* returned
* @param keyType the type of key that {@code m} is permitted to hold
* @param valueType the type of value that {@code m} is permitted to hold
* @return a dynamically typesafe view of the specified map
* @since 1.8
*/
public static <K,V> NavigableMap<K,V> checkedNavigableMap(NavigableMap<K, V> m,
Class<K> keyType,
Class<V> valueType) {
return new CheckedNavigableMap<>(m, keyType, valueType);
}
/**
* @serial include
*/
static class CheckedNavigableMap<K,V> extends CheckedSortedMap<K,V>
implements NavigableMap<K,V>, Serializable
{
private static final long serialVersionUID = -4852462692372534096L;
private final NavigableMap<K, V> nm;
CheckedNavigableMap(NavigableMap<K, V> m,
Class<K> keyType, Class<V> valueType) {
super(m, keyType, valueType);
nm = m;
}
public Comparator<? super K> comparator() { return nm.comparator(); }
public K firstKey() { return nm.firstKey(); }
public K lastKey() { return nm.lastKey(); }
public Entry<K, V> lowerEntry(K key) {
Entry<K,V> lower = nm.lowerEntry(key);
return (null != lower)
? new CheckedMap.CheckedEntrySet.CheckedEntry(lower, valueType)
: null;
}
public K lowerKey(K key) { return nm.lowerKey(key); }
public Entry<K, V> floorEntry(K key) {
Entry<K,V> floor = nm.floorEntry(key);
return (null != floor)
? new CheckedMap.CheckedEntrySet.CheckedEntry(floor, valueType)
: null;
}
public K floorKey(K key) { return nm.floorKey(key); }
public Entry<K, V> ceilingEntry(K key) {
Entry<K,V> ceiling = nm.ceilingEntry(key);
return (null != ceiling)
? new CheckedMap.CheckedEntrySet.CheckedEntry(ceiling, valueType)
: null;
}
public K ceilingKey(K key) { return nm.ceilingKey(key); }
public Entry<K, V> higherEntry(K key) {
Entry<K,V> higher = nm.higherEntry(key);
return (null != higher)
? new CheckedMap.CheckedEntrySet.CheckedEntry(higher, valueType)
: null;
}
public K higherKey(K key) { return nm.higherKey(key); }
public Entry<K, V> firstEntry() {
Entry<K,V> first = nm.firstEntry();
return (null != first)
? new CheckedMap.CheckedEntrySet.CheckedEntry(first, valueType)
: null;
}
public Entry<K, V> lastEntry() {
Entry<K,V> last = nm.lastEntry();
return (null != last)
? new CheckedMap.CheckedEntrySet.CheckedEntry(last, valueType)
: null;
}
public Entry<K, V> pollFirstEntry() {
Entry<K,V> entry = nm.pollFirstEntry();
return (null == entry)
? null
: new CheckedMap.CheckedEntrySet.CheckedEntry(entry, valueType);
}
public Entry<K, V> pollLastEntry() {
Entry<K,V> entry = nm.pollLastEntry();
return (null == entry)
? null
: new CheckedMap.CheckedEntrySet.CheckedEntry(entry, valueType);
}
public NavigableMap<K, V> descendingMap() {
return checkedNavigableMap(nm.descendingMap(), keyType, valueType);
}
public NavigableSet<K> keySet() {
return navigableKeySet();
}
public NavigableSet<K> navigableKeySet() {
return checkedNavigableSet(nm.navigableKeySet(), keyType);
}
public NavigableSet<K> descendingKeySet() {
return checkedNavigableSet(nm.descendingKeySet(), keyType);
}
@Override
public NavigableMap<K,V> subMap(K fromKey, K toKey) {
return checkedNavigableMap(nm.subMap(fromKey, true, toKey, false),
keyType, valueType);
}
@Override
public NavigableMap<K,V> headMap(K toKey) {
return checkedNavigableMap(nm.headMap(toKey, false), keyType, valueType);
}
@Override
public NavigableMap<K,V> tailMap(K fromKey) {
return checkedNavigableMap(nm.tailMap(fromKey, true), keyType, valueType);
}
public NavigableMap<K, V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
return checkedNavigableMap(nm.subMap(fromKey, fromInclusive, toKey, toInclusive), keyType, valueType);
}
public NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
return checkedNavigableMap(nm.headMap(toKey, inclusive), keyType, valueType);
}
public NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
return checkedNavigableMap(nm.tailMap(fromKey, inclusive), keyType, valueType);
}
}
// Empty collections // Empty collections
/** /**
...@@ -3428,6 +4165,7 @@ public class Collections { ...@@ -3428,6 +4165,7 @@ public class Collections {
* <p>Implementations of this method are permitted, but not * <p>Implementations of this method are permitted, but not
* required, to return the same object from multiple invocations. * required, to return the same object from multiple invocations.
* *
* @param <T> type of elements, if there were any, in the iterator
* @return an empty iterator * @return an empty iterator
* @since 1.7 * @since 1.7
*/ */
...@@ -3478,6 +4216,7 @@ public class Collections { ...@@ -3478,6 +4216,7 @@ public class Collections {
* <p>Implementations of this method are permitted, but not * <p>Implementations of this method are permitted, but not
* required, to return the same object from multiple invocations. * required, to return the same object from multiple invocations.
* *
* @param <T> type of elements, if there were any, in the iterator
* @return an empty list iterator * @return an empty list iterator
* @since 1.7 * @since 1.7
*/ */
...@@ -3542,17 +4281,19 @@ public class Collections { ...@@ -3542,17 +4281,19 @@ public class Collections {
public static final Set EMPTY_SET = new EmptySet<>(); public static final Set EMPTY_SET = new EmptySet<>();
/** /**
* Returns the empty set (immutable). This set is serializable. * Returns an empty set (immutable). This set is serializable.
* Unlike the like-named field, this method is parameterized. * Unlike the like-named field, this method is parameterized.
* *
* <p>This example illustrates the type-safe way to obtain an empty set: * <p>This example illustrates the type-safe way to obtain an empty set:
* <pre> * <pre>
* Set&lt;String&gt; s = Collections.emptySet(); * Set&lt;String&gt; s = Collections.emptySet();
* </pre> * </pre>
* Implementation note: Implementations of this method need not * @implNote Implementations of this method need not create a separate
* create a separate <tt>Set</tt> object for each call. Using this * {@code Set} object for each call. Using this method is likely to have
* method is likely to have comparable cost to using the like-named * comparable cost to using the like-named field. (Unlike this method, the
* field. (Unlike this method, the field does not provide type safety.) * field does not provide type safety.)
*
* @return the empty set
* *
* @see #EMPTY_SET * @see #EMPTY_SET
* @since 1.5 * @since 1.5
...@@ -3607,121 +4348,45 @@ public class Collections { ...@@ -3607,121 +4348,45 @@ public class Collections {
} }
/** /**
* Returns the empty sorted set (immutable). This set is serializable. * Returns an empty sorted set (immutable). This set is serializable.
* *
* <p>This example illustrates the type-safe way to obtain an empty sorted * <p>This example illustrates the type-safe way to obtain an empty
* set: * sorted set:
* <pre> * <pre> {@code
* SortedSet&lt;String&gt; s = Collections.emptySortedSet(); * SortedSet<String> s = Collections.emptySortedSet();
* </pre> * }</pre>
* Implementation note: Implementations of this method need not
* create a separate <tt>SortedSet</tt> object for each call.
* *
* @implNote Implementations of this method need not create a separate
* {@code SortedSet} object for each call.
*
* @param <E> type of elements, if there were any, in the set
* @return the empty sorted set
* @since 1.8 * @since 1.8
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public static final <E> SortedSet<E> emptySortedSet() { public static <E> SortedSet<E> emptySortedSet() {
return (SortedSet<E>) new EmptySortedSet<>(); return (SortedSet<E>) UnmodifiableNavigableSet.EMPTY_NAVIGABLE_SET;
} }
/** /**
* @serial include * Returns an empty navigable set (immutable). This set is serializable.
*
* <p>This example illustrates the type-safe way to obtain an empty
* navigable set:
* <pre> {@code
* NavigableSet<String> s = Collections.emptyNavigableSet();
* }</pre>
*
* @implNote Implementations of this method need not
* create a separate {@code NavigableSet} object for each call.
*
* @param <E> type of elements, if there were any, in the set
* @return the empty navigable set
* @since 1.8
*/ */
private static class EmptySortedSet<E> @SuppressWarnings("unchecked")
extends AbstractSet<E> public static <E> NavigableSet<E> emptyNavigableSet() {
implements SortedSet<E>, Serializable return (NavigableSet<E>) UnmodifiableNavigableSet.EMPTY_NAVIGABLE_SET;
{
private static final long serialVersionUID = 6316515401502265487L;
public Iterator<E> iterator() { return emptyIterator(); }
public int size() {return 0;}
public boolean isEmpty() {return true;}
public boolean contains(Object obj) {return false;}
public boolean containsAll(Collection<?> c) { return c.isEmpty(); }
public Object[] toArray() { return new Object[0]; }
public <E> E[] toArray(E[] a) {
if (a.length > 0)
a[0] = null;
return a;
}
// Preserves singleton property
private Object readResolve() {
return new EmptySortedSet<>();
}
@Override
public Comparator<? super E> comparator() {
return null;
}
@Override
@SuppressWarnings("unchecked")
public SortedSet<E> subSet(Object fromElement, Object toElement) {
Objects.requireNonNull(fromElement);
Objects.requireNonNull(toElement);
if (!(fromElement instanceof Comparable) ||
!(toElement instanceof Comparable))
{
throw new ClassCastException();
}
if ((((Comparable)fromElement).compareTo(toElement) >= 0) ||
(((Comparable)toElement).compareTo(fromElement) < 0))
{
throw new IllegalArgumentException();
}
return emptySortedSet();
}
@Override
public SortedSet<E> headSet(Object toElement) {
Objects.requireNonNull(toElement);
if (!(toElement instanceof Comparable)) {
throw new ClassCastException();
}
return emptySortedSet();
}
@Override
public SortedSet<E> tailSet(Object fromElement) {
Objects.requireNonNull(fromElement);
if (!(fromElement instanceof Comparable)) {
throw new ClassCastException();
}
return emptySortedSet();
}
@Override
public E first() {
throw new NoSuchElementException();
}
@Override
public E last() {
throw new NoSuchElementException();
}
// Override default methods in Collection
@Override
public void forEach(Consumer<? super E> action) {
Objects.requireNonNull(action);
}
@Override
public boolean removeIf(Predicate<? super E> filter) {
Objects.requireNonNull(filter);
return false;
}
@Override
public Spliterator<E> spliterator() { return Spliterators.emptySpliterator(); }
} }
/** /**
...@@ -3733,7 +4398,7 @@ public class Collections { ...@@ -3733,7 +4398,7 @@ public class Collections {
public static final List EMPTY_LIST = new EmptyList<>(); public static final List EMPTY_LIST = new EmptyList<>();
/** /**
* Returns the empty list (immutable). This list is serializable. * Returns an empty list (immutable). This list is serializable.
* *
* <p>This example illustrates the type-safe way to obtain an empty list: * <p>This example illustrates the type-safe way to obtain an empty list:
* <pre> * <pre>
...@@ -3744,6 +4409,9 @@ public class Collections { ...@@ -3744,6 +4409,9 @@ public class Collections {
* method is likely to have comparable cost to using the like-named * method is likely to have comparable cost to using the like-named
* field. (Unlike this method, the field does not provide type safety.) * field. (Unlike this method, the field does not provide type safety.)
* *
* @param <T> type of elements, if there were any, in the list
* @return an empty immutable list
*
* @see #EMPTY_LIST * @see #EMPTY_LIST
* @since 1.5 * @since 1.5
*/ */
...@@ -3830,17 +4498,18 @@ public class Collections { ...@@ -3830,17 +4498,18 @@ public class Collections {
public static final Map EMPTY_MAP = new EmptyMap<>(); public static final Map EMPTY_MAP = new EmptyMap<>();
/** /**
* Returns the empty map (immutable). This map is serializable. * Returns an empty map (immutable). This map is serializable.
* *
* <p>This example illustrates the type-safe way to obtain an empty set: * <p>This example illustrates the type-safe way to obtain an empty map:
* <pre> * <pre>
* Map&lt;String, Date&gt; s = Collections.emptyMap(); * Map&lt;String, Date&gt; s = Collections.emptyMap();
* </pre> * </pre>
* Implementation note: Implementations of this method need not * @implNote Implementations of this method need not create a separate
* create a separate <tt>Map</tt> object for each call. Using this * {@code Map} object for each call. Using this method is likely to have
* method is likely to have comparable cost to using the like-named * comparable cost to using the like-named field. (Unlike this method, the
* field. (Unlike this method, the field does not provide type safety.) * field does not provide type safety.)
* *
* @return an empty map
* @see #EMPTY_MAP * @see #EMPTY_MAP
* @since 1.5 * @since 1.5
*/ */
...@@ -3849,6 +4518,44 @@ public class Collections { ...@@ -3849,6 +4518,44 @@ public class Collections {
return (Map<K,V>) EMPTY_MAP; return (Map<K,V>) EMPTY_MAP;
} }
/**
* Returns an empty sorted map (immutable). This map is serializable.
*
* <p>This example illustrates the type-safe way to obtain an empty map:
* <pre> {@code
* SortedMap<String, Date> s = Collections.emptySortedMap();
* }</pre>
*
* @implNote Implementations of this method need not create a separate
* {@code SortedMap} object for each call.
*
* @return an empty sorted map
* @since 1.8
*/
@SuppressWarnings("unchecked")
public static final <K,V> SortedMap<K,V> emptySortedMap() {
return (SortedMap<K,V>) UnmodifiableNavigableMap.EMPTY_NAVIGABLE_MAP;
}
/**
* Returns an empty navigable map (immutable). This map is serializable.
*
* <p>This example illustrates the type-safe way to obtain an empty map:
* <pre> {@code
* NavigableMap<String, Date> s = Collections.emptyNavigableMap();
* }</pre>
*
* @implNote Implementations of this method need not create a separate
* {@code NavigableMap} object for each call.
*
* @return an empty navigable map
* @since 1.8
*/
@SuppressWarnings("unchecked")
public static final <K,V> NavigableMap<K,V> emptyNavigableMap() {
return (NavigableMap<K,V>) UnmodifiableNavigableMap.EMPTY_NAVIGABLE_MAP;
}
/** /**
* @serial include * @serial include
*/ */
...@@ -4153,15 +4860,11 @@ public class Collections { ...@@ -4153,15 +4860,11 @@ public class Collections {
v = value; v = value;
} }
public int size() {return 1;} public int size() {return 1;}
public boolean isEmpty() {return false;}
public boolean isEmpty() {return false;} public boolean containsKey(Object key) {return eq(key, k);}
public boolean containsValue(Object value) {return eq(value, v);}
public boolean containsKey(Object key) {return eq(key, k);} public V get(Object key) {return (eq(key, k) ? v : null);}
public boolean containsValue(Object value) {return eq(value, v);}
public V get(Object key) {return (eq(key, k) ? v : null);}
private transient Set<K> keySet = null; private transient Set<K> keySet = null;
private transient Set<Map.Entry<K,V>> entrySet = null; private transient Set<Map.Entry<K,V>> entrySet = null;
...@@ -4508,6 +5211,8 @@ public class Collections { ...@@ -4508,6 +5211,8 @@ public class Collections {
/** /**
* Returns true if the specified arguments are equal, or both null. * Returns true if the specified arguments are equal, or both null.
*
* NB: Do not replace with Object.equals until JDK-8015417 is resolved.
*/ */
static boolean eq(Object o1, Object o2) { static boolean eq(Object o1, Object o2) {
return o1==null ? o2==null : o1.equals(o2); return o1==null ? o2==null : o1.equals(o2);
......
src/share/classes/java/util/NavigableSet.java
浏览文件 @ d11eedbf
...@@ -303,7 +303,7 @@ public interface NavigableSet<E> extends SortedSet<E> { ...@@ -303,7 +303,7 @@ public interface NavigableSet<E> extends SortedSet<E> {
* @throws ClassCastException {@inheritDoc} * @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc} * @throws NullPointerException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc} * @throws IllegalArgumentException {@inheritDoc}
na */ */
SortedSet<E> headSet(E toElement); SortedSet<E> headSet(E toElement);
/** /**
......
test/java/util/Collection/MOAT.java
浏览文件 @ d11eedbf
...@@ -71,6 +71,14 @@ public class MOAT { ...@@ -71,6 +71,14 @@ public class MOAT {
testCollection(new LinkedList<Integer>()); testCollection(new LinkedList<Integer>());
testCollection(new LinkedList<Integer>().subList(0,0)); testCollection(new LinkedList<Integer>().subList(0,0));
testCollection(new TreeSet<Integer>()); 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>());
testCollection(new CopyOnWriteArrayList<Integer>().subList(0,0)); testCollection(new CopyOnWriteArrayList<Integer>().subList(0,0));
...@@ -98,6 +106,12 @@ public class MOAT { ...@@ -98,6 +106,12 @@ public class MOAT {
testMap(new Hashtable<Integer,Integer>()); testMap(new Hashtable<Integer,Integer>());
testMap(new ConcurrentHashMap<Integer,Integer>(10, 0.5f)); testMap(new ConcurrentHashMap<Integer,Integer>(10, 0.5f));
testMap(new ConcurrentSkipListMap<Integer,Integer>()); 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 // Empty collections
final List<Integer> emptyArray = Arrays.asList(new Integer[]{}); final List<Integer> emptyArray = Arrays.asList(new Integer[]{});
...@@ -117,19 +131,29 @@ public class MOAT { ...@@ -117,19 +131,29 @@ public class MOAT {
testCollection(emptySet); testCollection(emptySet);
testEmptySet(emptySet); testEmptySet(emptySet);
testEmptySet(EMPTY_SET); testEmptySet(EMPTY_SET);
testEmptySet(Collections.emptySet());
testEmptySet(Collections.emptySortedSet());
testEmptySet(Collections.emptyNavigableSet());
testImmutableSet(emptySet); testImmutableSet(emptySet);
List<Integer> emptyList = emptyList(); List<Integer> emptyList = emptyList();
testCollection(emptyList); testCollection(emptyList);
testEmptyList(emptyList); testEmptyList(emptyList);
testEmptyList(EMPTY_LIST); testEmptyList(EMPTY_LIST);
testEmptyList(Collections.emptyList());
testImmutableList(emptyList); testImmutableList(emptyList);
Map<Integer,Integer> emptyMap = emptyMap(); Map<Integer,Integer> emptyMap = emptyMap();
testMap(emptyMap); testMap(emptyMap);
testEmptyMap(emptyMap); testEmptyMap(emptyMap);
testEmptyMap(EMPTY_MAP); testEmptyMap(EMPTY_MAP);
testEmptyMap(Collections.emptyMap());
testEmptyMap(Collections.emptySortedMap());
testEmptyMap(Collections.emptyNavigableMap());
testImmutableMap(emptyMap); testImmutableMap(emptyMap);
testImmutableMap(Collections.emptyMap());
testImmutableMap(Collections.emptySortedMap());
testImmutableMap(Collections.emptyNavigableMap());
// Singleton collections // Singleton collections
Set<Integer> singletonSet = singleton(1); Set<Integer> singletonSet = singleton(1);
......
test/java/util/Collections/CheckedIdentityMap.java
浏览文件 @ d11eedbf
...@@ -24,59 +24,42 @@ ...@@ -24,59 +24,42 @@
/* /*
* @test * @test
* @bug 6585904 * @bug 6585904
* @run testng CheckedIdentityMap
* @summary Checked collections with underlying maps with identity comparisons * @summary Checked collections with underlying maps with identity comparisons
*/ */
import java.util.*; import java.util.*;
import static java.util.Collections.*; 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 { public class CheckedIdentityMap {
void test(String[] args) throws Throwable {
@Test
public void testHashCode() {
Map<Integer, Integer> m1 = checkedMap( Map<Integer, Integer> m1 = checkedMap(
new IdentityHashMap<Integer, Integer>(), new IdentityHashMap<Integer, Integer>(),
Integer.class, Integer.class); Integer.class, Integer.class);
Map<Integer, Integer> m2 = checkedMap( Map<Integer, Integer> m2 = checkedMap(
new IdentityHashMap<Integer, Integer>(), new IdentityHashMap<Integer, Integer>(),
Integer.class, Integer.class); Integer.class, Integer.class);
// NB: these are unique instances. Compare vs. Integer.valueOf(1)
m1.put(new Integer(1), new Integer(1)); m1.put(new Integer(1), new Integer(1));
m2.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> e1 = m1.entrySet().iterator().next();
Map.Entry<Integer, Integer> e2 = m2.entrySet().iterator().next(); Map.Entry<Integer, Integer> e2 = m2.entrySet().iterator().next();
check(! e1.equals(e2));
check(e1.hashCode() == hashCode(e1)); assertNotEquals(e1, e2);
check(e2.hashCode() == hashCode(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()) ^ return (System.identityHashCode(e.getKey()) ^
System.identityHashCode(e.getValue())); 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);}}};}
} }
test/java/util/Collections/CheckedMapBash.java
浏览文件 @ d11eedbf
...@@ -23,76 +23,83 @@ ...@@ -23,76 +23,83 @@
/* /*
* @test * @test
* @bug 4904067 5023830 * @bug 4904067 5023830 7129185
* @summary Unit test for Collections.checkedMap * @summary Unit test for Collections.checkedMap
* @author Josh Bloch * @author Josh Bloch
* @run testng CheckedMapBash
*/ */
import java.util.*; 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 { public class CheckedMapBash {
static Random rnd = new Random(); static final Random rnd = new Random();
static Object nil = new Integer(0); static final Object nil = new Integer(0);
static final int numItr = 100;
public static void main(String[] args) { static final int mapSize = 100;
int numItr = 100;
int mapSize = 100; @Test(dataProvider = "Bash.Supplier<Map<Integer,Integer>>")
public static void testCheckedMap(String description, Supplier<Map<Integer,Integer>> supplier) {
// Linked List test Map m = supplier.get();
for (int i=0; i<numItr; i++) { Object head = nil;
Map m = newMap();
Object head = nil; for (int j=0; j<mapSize; j++) {
Object newHead;
for (int j=0; j<mapSize; j++) { do {
Object newHead; newHead = new Integer(rnd.nextInt());
do { } while (m.containsKey(newHead));
newHead = new Integer(rnd.nextInt()); m.put(newHead, head);
} while (m.containsKey(newHead)); head = newHead;
m.put(newHead, head); }
head = newHead; if (m.size() != mapSize)
} fail("Size not as expected.");
if (m.size() != mapSize)
fail("Size not as expected."); {
HashMap hm = new HashMap(m);
{ if (! (hm.hashCode() == m.hashCode() &&
HashMap hm = new HashMap(m); hm.entrySet().hashCode() == m.entrySet().hashCode() &&
if (! (hm.hashCode() == m.hashCode() && hm.keySet().hashCode() == m.keySet().hashCode()))
hm.entrySet().hashCode() == m.entrySet().hashCode() && fail("Incorrect hashCode computation.");
hm.keySet().hashCode() == m.keySet().hashCode()))
fail("Incorrect hashCode computation."); if (! (hm.equals(m) &&
hm.entrySet().equals(m.entrySet()) &&
if (! (hm.equals(m) && hm.keySet().equals(m.keySet()) &&
hm.entrySet().equals(m.entrySet()) && m.equals(hm) &&
hm.keySet().equals(m.keySet()) && m.entrySet().equals(hm.entrySet()) &&
m.equals(hm) && m.keySet().equals(hm.keySet())))
m.entrySet().equals(hm.entrySet()) && fail("Incorrect equals computation.");
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.");
} }
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++) for (int i=0; i<mapSize; i++)
if (m.put(new Integer(i), new Integer(2*i)) != null) if (m.put(new Integer(i), new Integer(2*i)) != null)
fail("put returns a non-null value erroenously."); fail("put returns a non-null value erroenously.");
...@@ -101,7 +108,7 @@ public class CheckedMapBash { ...@@ -101,7 +108,7 @@ public class CheckedMapBash {
fail("contains value "+i); fail("contains value "+i);
if (m.put(nil, nil) == null) if (m.put(nil, nil) == null)
fail("put returns a null value erroenously."); fail("put returns a null value erroenously.");
Map m2 = newMap(); m2.putAll(m); Map m2 = supplier.get(); m2.putAll(m);
if (!m.equals(m2)) if (!m.equals(m2))
fail("Clone not equal to original. (1)"); fail("Clone not equal to original. (1)");
if (!m2.equals(m)) if (!m2.equals(m))
...@@ -134,16 +141,36 @@ public class CheckedMapBash { ...@@ -134,16 +141,36 @@ public class CheckedMapBash {
fail("Iterator.remove() failed"); fail("Iterator.remove() failed");
} }
static Map newMap() {
Map m = Collections.checkedMap(new HashMap(),
Integer.class, Integer.class);
if (!m.isEmpty()) @DataProvider(name = "Bash.Supplier<Map<Integer,Integer>>", parallel = true)
fail("New instance non empty."); public static Iterator<Object[]> bashNavigableMapProvider() {
return m; ArrayList<Object[]> iters = new ArrayList<>(makeCheckedMaps());
iters.ensureCapacity(numItr * iters.size());
for(int each=1; each < numItr; each++) {
iters.addAll( makeCheckedMaps());
}
return iters.iterator();
}
@DataProvider(name = "Supplier<Map<Integer,Integer>>", parallel = true)
public static Iterator<Object[]> navigableMapProvider() {
return makeCheckedMaps().iterator();
} }
static void fail(String s) { public static Collection<Object[]> makeCheckedMaps() {
throw new RuntimeException(s); 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);}}
);
} }
} }
test/java/util/Collections/CheckedSetBash.java
浏览文件 @ d11eedbf
...@@ -23,82 +23,93 @@ ...@@ -23,82 +23,93 @@
/* /*
* @test * @test
* @bug 4904067 * @bug 4904067 7129185
* @summary Unit test for Collections.checkedSet * @summary Unit test for Collections.checkedSet
* @author Josh Bloch * @author Josh Bloch
* @run testng CheckedSetBash
*/ */
import java.util.*; 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 { public class CheckedSetBash {
static Random rnd = new Random(); static final int numItr = 100;
static final int setSize = 100;
public static void main(String[] args) { static final Random rnd = new Random();
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(); Set<Integer> s1 = supplier.get();
AddRandoms(s1, setSize); assertTrue(s1.isEmpty());
Set s2 = newSet(); AddRandoms(s1, setSize);
AddRandoms(s2, setSize);
Set<Integer> s2 = supplier.get();
Set intersection = clone(s1);
intersection.retainAll(s2); assertTrue(s2.isEmpty());
Set diff1 = clone(s1); diff1.removeAll(s2);
Set diff2 = clone(s2); diff2.removeAll(s1); AddRandoms(s2, setSize);
Set union = clone(s1); union.addAll(s2);
Set<Integer> intersection = clone(s1, supplier);
if (diff1.removeAll(diff2)) intersection.retainAll(s2);
fail("Set algebra identity 2 failed"); Set<Integer> diff1 = clone(s1, supplier); diff1.removeAll(s2);
if (diff1.removeAll(intersection)) Set<Integer> diff2 = clone(s2, supplier); diff2.removeAll(s1);
fail("Set algebra identity 3 failed"); Set<Integer> union = clone(s1, supplier); union.addAll(s2);
if (diff2.removeAll(diff1))
fail("Set algebra identity 4 failed"); if (diff1.removeAll(diff2))
if (diff2.removeAll(intersection)) fail("Set algebra identity 2 failed");
fail("Set algebra identity 5 failed"); if (diff1.removeAll(intersection))
if (intersection.removeAll(diff1)) fail("Set algebra identity 3 failed");
fail("Set algebra identity 6 failed"); if (diff2.removeAll(diff1))
if (intersection.removeAll(diff1)) fail("Set algebra identity 4 failed");
fail("Set algebra identity 7 failed"); if (diff2.removeAll(intersection))
fail("Set algebra identity 5 failed");
intersection.addAll(diff1); intersection.addAll(diff2); if (intersection.removeAll(diff1))
if (!intersection.equals(union)) fail("Set algebra identity 6 failed");
fail("Set algebra identity 1 failed"); if (intersection.removeAll(diff1))
fail("Set algebra identity 7 failed");
if (new HashSet(union).hashCode() != union.hashCode())
fail("Incorrect hashCode computation."); intersection.addAll(diff1); intersection.addAll(diff2);
if (!intersection.equals(union))
Iterator e = union.iterator(); fail("Set algebra identity 1 failed");
while (e.hasNext())
if (!intersection.remove(e.next())) if (new HashSet(union).hashCode() != union.hashCode())
fail("Couldn't remove element from copy."); fail("Incorrect hashCode computation.");
if (!intersection.isEmpty())
fail("Copy nonempty after deleting all elements."); Iterator e = union.iterator();
while (e.hasNext())
e = union.iterator(); if (!intersection.remove(e.next()))
while (e.hasNext()) { fail("Couldn't remove element from copy.");
Object o = e.next(); if (!intersection.isEmpty())
if (!union.contains(o)) fail("Copy nonempty after deleting all elements.");
fail("Set doesn't contain one of its elements.");
e.remove(); e = union.iterator();
if (union.contains(o)) while (e.hasNext()) {
fail("Set contains element after deletion."); Object o = e.next();
} if (!union.contains(o))
if (!union.isEmpty()) fail("Set doesn't contain one of its elements.");
fail("Set nonempty after deleting all elements."); e.remove();
if (union.contains(o))
s1.clear(); fail("Set contains element after deletion.");
if (!s1.isEmpty())
fail("Set nonempty after clear.");
} }
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 // Done inefficiently so as to exercise toArray
static Set clone(Set s) { static <T> Set<T> clone(Set<T> s, Supplier<Set<T>> supplier) {
Set clone = newSet(); Set<T> clone = supplier.get();
List arrayList = Arrays.asList(s.toArray()); List<T> arrayList = Arrays.asList((T[]) s.toArray());
clone.addAll(arrayList); clone.addAll(arrayList);
if (!s.equals(clone)) if (!s.equals(clone))
fail("Set not equal to copy."); fail("Set not equal to copy.");
...@@ -109,13 +120,6 @@ public class CheckedSetBash { ...@@ -109,13 +120,6 @@ public class CheckedSetBash {
return clone; 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) { static void AddRandoms(Set s, int n) {
for (int i=0; i<n; i++) { for (int i=0; i<n; i++) {
int r = rnd.nextInt() % n; int r = rnd.nextInt() % n;
...@@ -136,8 +140,30 @@ public class CheckedSetBash { ...@@ -136,8 +140,30 @@ public class CheckedSetBash {
} }
} }
static void fail(String s) { @DataProvider(name = "Supplier<Set<Integer>>", parallel = true)
throw new RuntimeException(s); 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);}}
);
} }
} }
test/java/util/Collections/EmptyCollectionSerialization.java
浏览文件 @ d11eedbf
...@@ -23,13 +23,20 @@ ...@@ -23,13 +23,20 @@
/* /*
* @test * @test
* @bug 4684279 * @bug 4684279 7129185
* @summary Empty utility collections should be singletons * @summary Empty utility collections should be singletons
* @author Josh Bloch * @author Josh Bloch
* @run testng EmptyCollectionSerialization
*/ */
import java.util.*; import java.util.*;
import java.util.function.Supplier;
import java.io.*; 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 { public class EmptyCollectionSerialization {
private static Object patheticDeepCopy(Object o) throws Exception { private static Object patheticDeepCopy(Object o) throws Exception {
...@@ -45,16 +52,48 @@ public class EmptyCollectionSerialization { ...@@ -45,16 +52,48 @@ public class EmptyCollectionSerialization {
return ois.readObject(); return ois.readObject();
} }
private static boolean isSingleton(Object o) throws Exception { @Test(dataProvider="SerializableSingletons")
return patheticDeepCopy(o) == o; 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);
}
}
@DataProvider(name = "SerializableSingletons", parallel = true)
public static Iterator<Object[]> navigableMapProvider() {
return makeSingletons().iterator();
} }
public static void main(String[] args) throws Exception { public static Collection<Object[]> makeSingletons() {
if (!isSingleton(Collections.EMPTY_SET)) return Arrays.asList(
throw new Exception("EMPTY_SET"); new Object[]{"Collections.EMPTY_LIST",
if (!isSingleton(Collections.EMPTY_LIST)) (Supplier) () -> {return Collections.EMPTY_LIST;}},
throw new Exception("EMPTY_LIST"); new Object[]{"Collections.EMPTY_MAP",
if (!isSingleton(Collections.EMPTY_MAP)) (Supplier) () -> {return Collections.EMPTY_MAP;}},
throw new Exception("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();}}
);
} }
} }
test/java/util/Collections/EmptyNavigableMap.java 0 → 100644
浏览文件 @ d11eedbf
/*
* 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()}
);
}
}
test/java/util/Collections/EmptyNavigableSet.java 0 → 100644
浏览文件 @ d11eedbf
/*
* 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()}
);
}
}
test/java/util/Collections/EmptySortedSet.java 已删除 100644 → 0
浏览文件 @ e5c1052c
/*
* 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.");
}
}
}
test/java/util/Map/LockStep.java
浏览文件 @ d11eedbf
...@@ -100,7 +100,14 @@ public class LockStep { ...@@ -100,7 +100,14 @@ public class LockStep {
new Hashtable(16), new Hashtable(16),
new TreeMap(), new TreeMap(),
new ConcurrentHashMap(16), 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++) for (int j = 0; j < 10; j++)
put(maps, r.nextInt(100), r.nextInt(100)); put(maps, r.nextInt(100), r.nextInt(100));
......
test/java/util/NavigableMap/LockStep.java
浏览文件 @ d11eedbf
...@@ -55,11 +55,19 @@ public class LockStep { ...@@ -55,11 +55,19 @@ public class LockStep {
lockSteps(new TreeMap(), lockSteps(new TreeMap(),
new ConcurrentSkipListMap()); new ConcurrentSkipListMap());
lockSteps(new TreeMap(),
Collections.checkedNavigableMap(new TreeMap(), Integer.class, Integer.class));
lockSteps(new TreeMap(),
Collections.synchronizedNavigableMap(new TreeMap()));
lockSteps(new TreeMap(reverseOrder()), lockSteps(new TreeMap(reverseOrder()),
new ConcurrentSkipListMap(reverseOrder())); new ConcurrentSkipListMap(reverseOrder()));
lockSteps(new TreeSet(), lockSteps(new TreeSet(),
new ConcurrentSkipListSet()); new ConcurrentSkipListSet());
lockSteps(new TreeSet(),
Collections.checkedNavigableSet(new TreeSet(), Integer.class));
lockSteps(new TreeSet(),
Collections.synchronizedNavigableSet(new TreeSet()));
lockSteps(new TreeSet(reverseOrder()), lockSteps(new TreeSet(reverseOrder()),
new ConcurrentSkipListSet(reverseOrder())); new ConcurrentSkipListSet(reverseOrder()));
} }
...@@ -181,7 +189,15 @@ public class LockStep { ...@@ -181,7 +189,15 @@ public class LockStep {
testEmptyCollection(m.values()); 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) { static void equalNext(final Iterator<?> it, Object expected) {
if (maybe(2)) if (maybe(2))
...@@ -208,8 +224,15 @@ public class LockStep { ...@@ -208,8 +224,15 @@ public class LockStep {
check(s.descendingSet().descendingSet().comparator() == null); check(s.descendingSet().descendingSet().comparator() == null);
equal(s.isEmpty(), s.size() == 0); equal(s.isEmpty(), s.size() == 0);
equal2(s, s.descendingSet()); equal2(s, s.descendingSet());
if (maybe(4) && s instanceof Serializable) if (maybe(4) && s instanceof Serializable) {
equal2(s, serialClone(s)); try {
equal2(s, serialClone(s));
} catch(RuntimeException uhoh) {
if(!(uhoh.getCause() instanceof NotSerializableException)) {
throw uhoh;
}
}
}
Comparator cmp = comparator(s); Comparator cmp = comparator(s);
if (s.isEmpty()) { if (s.isEmpty()) {
THROWS(NoSuchElementException.class, THROWS(NoSuchElementException.class,
...@@ -276,6 +299,15 @@ public class LockStep { ...@@ -276,6 +299,15 @@ public class LockStep {
check(! it2.hasNext()); 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, static void equalNavigableSetsLeaf(final NavigableSet s1,
final NavigableSet s2) { final NavigableSet s2) {
equal2(s1, s2); equal2(s1, s2);
...@@ -448,8 +480,7 @@ public class LockStep { ...@@ -448,8 +480,7 @@ public class LockStep {
static void equalNavigableMaps(NavigableMap m1, static void equalNavigableMaps(NavigableMap m1,
NavigableMap m2) { NavigableMap m2) {
equalNavigableMapsLeaf(m1, m2); equalNavigableMapsLeaf(m1, m2);
equalNavigableSetsLeaf((NavigableSet) m1.keySet(), equalSetsLeaf(m1.keySet(), m2.keySet());
(NavigableSet) m2.keySet());
equalNavigableSets(m1.navigableKeySet(), equalNavigableSets(m1.navigableKeySet(),
m2.navigableKeySet()); m2.navigableKeySet());
equalNavigableSets(m1.descendingKeySet(), equalNavigableSets(m1.descendingKeySet(),
...@@ -836,5 +867,7 @@ public class LockStep { ...@@ -836,5 +867,7 @@ public class LockStep {
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
static <T> T serialClone(T obj) { static <T> T serialClone(T obj) {
try { return (T) readObject(serializedForm(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); }
}
} }
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或