8017447: Unmodifiable map entry becomes modifiable if taken from a stream of map entries
Reviewed-by: briangoetz
This commit is contained in:
Paul Sandoz
parent
2241a3720d
commit
b47a003232
@ -34,6 +34,8 @@ import java.util.function.Consumer;
|
||||
import java.util.function.Function;
|
||||
import java.util.function.Predicate;
|
||||
import java.util.function.UnaryOperator;
|
||||
import java.util.stream.Stream;
|
||||
import java.util.stream.StreamSupport;
|
||||
|
||||
/**
|
||||
* This class consists exclusively of static methods that operate on or return
|
||||
@ -1510,6 +1512,86 @@ public class Collections {
|
||||
// Need to cast to raw in order to work around a limitation in the type system
|
||||
super((Set)s);
|
||||
}
|
||||
|
||||
static <K, V> Consumer<Map.Entry<K, V>> entryConsumer(Consumer<? super Entry<K, V>> action) {
|
||||
return e -> action.accept(new UnmodifiableEntry<>(e));
|
||||
}
|
||||
|
||||
public void forEach(Consumer<? super Entry<K, V>> action) {
|
||||
Objects.requireNonNull(action);
|
||||
c.forEach(entryConsumer(action));
|
||||
}
|
||||
|
||||
static final class UnmodifiableEntrySetSpliterator<K, V>
|
||||
implements Spliterator<Entry<K,V>> {
|
||||
final Spliterator<Map.Entry<K, V>> s;
|
||||
|
||||
UnmodifiableEntrySetSpliterator(Spliterator<Entry<K, V>> s) {
|
||||
this.s = s;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean tryAdvance(Consumer<? super Entry<K, V>> action) {
|
||||
Objects.requireNonNull(action);
|
||||
return s.tryAdvance(entryConsumer(action));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void forEachRemaining(Consumer<? super Entry<K, V>> action) {
|
||||
Objects.requireNonNull(action);
|
||||
s.forEachRemaining(entryConsumer(action));
|
||||
}
|
||||
|
||||
@Override
|
||||
public Spliterator<Entry<K, V>> trySplit() {
|
||||
Spliterator<Entry<K, V>> split = s.trySplit();
|
||||
return split == null
|
||||
? null
|
||||
: new UnmodifiableEntrySetSpliterator<>(split);
|
||||
}
|
||||
|
||||
@Override
|
||||
public long estimateSize() {
|
||||
return s.estimateSize();
|
||||
}
|
||||
|
||||
@Override
|
||||
public long getExactSizeIfKnown() {
|
||||
return s.getExactSizeIfKnown();
|
||||
}
|
||||
|
||||
@Override
|
||||
public int characteristics() {
|
||||
return s.characteristics();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasCharacteristics(int characteristics) {
|
||||
return s.hasCharacteristics(characteristics);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Comparator<? super Entry<K, V>> getComparator() {
|
||||
return s.getComparator();
|
||||
}
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public Spliterator<Entry<K,V>> spliterator() {
|
||||
return new UnmodifiableEntrySetSpliterator<>(
|
||||
(Spliterator<Map.Entry<K, V>>) c.spliterator());
|
||||
}
|
||||
|
||||
@Override
|
||||
public Stream<Entry<K,V>> stream() {
|
||||
return StreamSupport.stream(spliterator());
|
||||
}
|
||||
|
||||
@Override
|
||||
public Stream<Entry<K,V>> parallelStream() {
|
||||
return StreamSupport.parallelStream(spliterator());
|
||||
}
|
||||
|
||||
public Iterator<Map.Entry<K,V>> iterator() {
|
||||
return new Iterator<Map.Entry<K,V>>() {
|
||||
private final Iterator<? extends Map.Entry<? extends K, ? extends V>> i = c.iterator();
|
||||
|
||||
164
jdk/test/java/util/Collections/UnmodifiableMapEntrySet.java
Normal file
164
jdk/test/java/util/Collections/UnmodifiableMapEntrySet.java
Normal file
@ -0,0 +1,164 @@
|
||||
/*
|
||||
* Copyright (c) 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
|
||||
* @run testng UnmodifiableMapEntrySet
|
||||
* @summary Unit tests for wrapping classes should delegate to default methods
|
||||
*/
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Spliterator;
|
||||
import java.util.TreeMap;
|
||||
import java.util.function.Consumer;
|
||||
import java.util.function.Function;
|
||||
import java.util.function.Supplier;
|
||||
|
||||
import org.testng.annotations.Test;
|
||||
import org.testng.annotations.DataProvider;
|
||||
|
||||
import static org.testng.Assert.assertEquals;
|
||||
|
||||
@Test(groups = "unit")
|
||||
public class UnmodifiableMapEntrySet {
|
||||
static Object[][] collections;
|
||||
|
||||
static <M extends Map<Integer, Integer>> M fillMap(int size, M m) {
|
||||
for (int i = 0; i < size; i++) {
|
||||
m.put(i, i);
|
||||
}
|
||||
return m;
|
||||
}
|
||||
|
||||
@DataProvider(name="maps")
|
||||
static Object[][] mapCases() {
|
||||
if (collections != null) {
|
||||
return collections;
|
||||
}
|
||||
|
||||
List<Object[]> cases = new ArrayList<>();
|
||||
for (int size : new int[] {1, 2, 16}) {
|
||||
cases.add(new Object[] {
|
||||
String.format("new HashMap(%d)", size),
|
||||
(Supplier<Map<Integer, Integer>>)
|
||||
() -> Collections.unmodifiableMap(fillMap(size, new HashMap<>())) });
|
||||
cases.add(new Object[] {
|
||||
String.format("new TreeMap(%d)", size),
|
||||
(Supplier<Map<Integer, Integer>>)
|
||||
() -> Collections.unmodifiableSortedMap(fillMap(size, new TreeMap<>())) });
|
||||
}
|
||||
|
||||
return cases.toArray(new Object[0][]);
|
||||
}
|
||||
|
||||
static class EntryConsumer implements Consumer<Map.Entry<Integer, Integer>> {
|
||||
int updates;
|
||||
@Override
|
||||
public void accept(Map.Entry<Integer, Integer> me) {
|
||||
try {
|
||||
me.setValue(Integer.MAX_VALUE);
|
||||
updates++;
|
||||
} catch (UnsupportedOperationException e) {
|
||||
}
|
||||
}
|
||||
|
||||
void assertNoUpdates() {
|
||||
assertEquals(updates, 0, "Updates to entries");
|
||||
}
|
||||
}
|
||||
|
||||
void testWithEntryConsumer(Consumer<EntryConsumer> c) {
|
||||
EntryConsumer ec = new EntryConsumer();
|
||||
c.accept(ec);
|
||||
ec.assertNoUpdates();
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maps")
|
||||
public void testForEach(String d, Supplier<Map<Integer, Integer>> ms) {
|
||||
testWithEntryConsumer(
|
||||
ec -> ms.get().entrySet().forEach(ec));
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maps")
|
||||
public void testIteratorForEachRemaining(String d, Supplier<Map<Integer, Integer>> ms) {
|
||||
testWithEntryConsumer(
|
||||
ec -> ms.get().entrySet().iterator().forEachRemaining(ec));
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maps")
|
||||
public void testIteratorNext(String d, Supplier<Map<Integer, Integer>> ms) {
|
||||
testWithEntryConsumer(ec -> {
|
||||
for (Map.Entry<Integer, Integer> me : ms.get().entrySet()) {
|
||||
ec.accept(me);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maps")
|
||||
public void testSpliteratorForEachRemaining(String d, Supplier<Map<Integer, Integer>> ms) {
|
||||
testSpliterator(
|
||||
ms.get().entrySet()::spliterator,
|
||||
// Higher order function returning a consumer that
|
||||
// traverses all spliterator elements using an EntryConsumer
|
||||
s -> ec -> s.forEachRemaining(ec));
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maps")
|
||||
public void testSpliteratorTryAdvance(String d, Supplier<Map<Integer, Integer>> ms) {
|
||||
testSpliterator(
|
||||
ms.get().entrySet()::spliterator,
|
||||
// Higher order function returning a consumer that
|
||||
// traverses all spliterator elements using an EntryConsumer
|
||||
s -> ec -> { while (s.tryAdvance(ec)); });
|
||||
}
|
||||
|
||||
void testSpliterator(Supplier<Spliterator<Map.Entry<Integer, Integer>>> ss,
|
||||
// Higher order function that given a spliterator returns a
|
||||
// consumer for that spliterator which traverses elements
|
||||
// using an EntryConsumer
|
||||
Function<Spliterator<Map.Entry<Integer, Integer>>, Consumer<EntryConsumer>> sc) {
|
||||
testWithEntryConsumer(sc.apply(ss.get()));
|
||||
|
||||
Spliterator<Map.Entry<Integer, Integer>> s = ss.get();
|
||||
Spliterator<Map.Entry<Integer, Integer>> split = s.trySplit();
|
||||
if (split != null) {
|
||||
testWithEntryConsumer(sc.apply(split));
|
||||
testWithEntryConsumer(sc.apply(s));
|
||||
}
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maps")
|
||||
public void testStreamForEach(String d, Supplier<Map<Integer, Integer>> ms) {
|
||||
testWithEntryConsumer(ec -> ms.get().entrySet().stream().forEach(ec));
|
||||
}
|
||||
|
||||
@Test(dataProvider = "maps")
|
||||
public void testParallelStreamForEach(String d, Supplier<Map<Integer, Integer>> ms) {
|
||||
testWithEntryConsumer(ec -> ms.get().entrySet().parallelStream().forEach(ec));
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user