967 lines
41 KiB
Java
967 lines
41 KiB
Java
/*
|
|
* Copyright (c) 2023, 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.
|
|
*/
|
|
|
|
import java.io.*;
|
|
import java.util.*;
|
|
|
|
import org.testng.annotations.DataProvider;
|
|
import org.testng.annotations.Test;
|
|
|
|
import static org.testng.Assert.assertEquals;
|
|
import static org.testng.Assert.assertNull;
|
|
import static org.testng.Assert.assertThrows;
|
|
import static org.testng.Assert.assertFalse;
|
|
import static org.testng.Assert.assertSame;
|
|
import static org.testng.Assert.assertTrue;
|
|
|
|
/*
|
|
* @test
|
|
* @bug 8266571
|
|
* @summary Basic tests for SequencedMap
|
|
* @modules java.base/java.util:open
|
|
* @build SimpleSortedMap
|
|
* @run testng BasicMap
|
|
*/
|
|
|
|
public class BasicMap {
|
|
|
|
// ========== Data Providers ==========
|
|
|
|
static final Class<? extends Throwable> CCE = ClassCastException.class;
|
|
static final Class<? extends Throwable> NSEE = NoSuchElementException.class;
|
|
static final Class<? extends Throwable> UOE = UnsupportedOperationException.class;
|
|
|
|
static final List<Map.Entry<String, Integer>> ORIGINAL =
|
|
List.of(Map.entry("a", 1),
|
|
Map.entry("b", 2),
|
|
Map.entry("c", 3),
|
|
Map.entry("d", 4),
|
|
Map.entry("e", 5));
|
|
|
|
static <M extends SequencedMap<String, Integer>>
|
|
M load(M map, List<Map.Entry<String, Integer>> mappings) {
|
|
for (var e : mappings)
|
|
map.put(e.getKey(), e.getValue());
|
|
return map;
|
|
}
|
|
|
|
static NavigableMap<String, Integer> cknav(NavigableMap<String, Integer> map) {
|
|
return Collections.checkedNavigableMap(map, String.class, Integer.class);
|
|
}
|
|
|
|
static SortedMap<String, Integer> cksorted(SortedMap<String, Integer> map) {
|
|
return Collections.checkedSortedMap(map, String.class, Integer.class);
|
|
}
|
|
|
|
static SequencedMap<String, Integer> umap(SequencedMap<String, Integer> map) {
|
|
return Collections.unmodifiableSequencedMap(map);
|
|
}
|
|
|
|
static SortedMap<String, Integer> usorted(SortedMap<String, Integer> map) {
|
|
return Collections.unmodifiableSortedMap(map);
|
|
}
|
|
|
|
static NavigableMap<String, Integer> unav(NavigableMap<String, Integer> map) {
|
|
return Collections.unmodifiableNavigableMap(map);
|
|
}
|
|
|
|
@DataProvider(name="all")
|
|
public Iterator<Object[]> all() {
|
|
var result = new ArrayList<Object[]>();
|
|
populated().forEachRemaining(result::add);
|
|
empties().forEachRemaining(result::add);
|
|
return result.iterator();
|
|
}
|
|
|
|
@DataProvider(name="populated")
|
|
public Iterator<Object[]> populated() {
|
|
return Arrays.asList(
|
|
new Object[] { "LinkedHashMap", load(new LinkedHashMap<>(), ORIGINAL), ORIGINAL },
|
|
new Object[] { "SimpleSortedMap", load(new SimpleSortedMap<>(), ORIGINAL), ORIGINAL },
|
|
new Object[] { "TreeMap", load(new TreeMap<>(), ORIGINAL), ORIGINAL },
|
|
new Object[] { "UnmodMap", umap(load(new LinkedHashMap<>(), ORIGINAL)), ORIGINAL }
|
|
).iterator();
|
|
}
|
|
|
|
@DataProvider(name="empties")
|
|
public Iterator<Object[]> empties() {
|
|
return Arrays.asList(
|
|
new Object[] { "EmptyNavigableMap", Collections.emptyNavigableMap(), List.of() },
|
|
new Object[] { "EmptySortedMap", Collections.emptySortedMap(), List.of() },
|
|
new Object[] { "LinkedHashMap", new LinkedHashMap<>(), List.of() },
|
|
new Object[] { "SimpleSortedMap", new SimpleSortedMap<>(), List.of() },
|
|
new Object[] { "TreeMap", new TreeMap<>(), List.of() },
|
|
new Object[] { "UnmodMap", umap(new LinkedHashMap<>()), List.of() }
|
|
).iterator();
|
|
}
|
|
|
|
@DataProvider(name="polls")
|
|
public Iterator<Object[]> polls() {
|
|
return Arrays.asList(
|
|
new Object[] { "LinkedHashMap", load(new LinkedHashMap<>(), ORIGINAL), ORIGINAL },
|
|
new Object[] { "SimpleSortedMap", load(new SimpleSortedMap<>(), ORIGINAL), ORIGINAL },
|
|
new Object[] { "TreeMap", load(new TreeMap<>(), ORIGINAL), ORIGINAL }
|
|
).iterator();
|
|
}
|
|
|
|
@DataProvider(name="emptyPolls")
|
|
public Iterator<Object[]> emptyPolls() {
|
|
return Arrays.asList(
|
|
new Object[] { "LinkedHashMap", new LinkedHashMap<>(), List.of() },
|
|
new Object[] { "SimpleSortedMap", new SimpleSortedMap<>(), List.of() },
|
|
new Object[] { "TreeMap", new TreeMap<>(), List.of() }
|
|
).iterator();
|
|
}
|
|
|
|
@DataProvider(name="puts")
|
|
public Iterator<Object[]> puts() {
|
|
return Arrays.<Object[]>asList(
|
|
new Object[] { "LinkedHashMap", load(new LinkedHashMap<>(), ORIGINAL), ORIGINAL }
|
|
).iterator();
|
|
}
|
|
|
|
@DataProvider(name="putUnpositioned")
|
|
public Iterator<Object[]> putUnpositioned() {
|
|
return Arrays.asList(
|
|
new Object[] { "LinkedHashMap", false, load(new LinkedHashMap<>(), ORIGINAL), ORIGINAL },
|
|
new Object[] { "LinkedHashMap", true, load(new LinkedHashMap<>(), ORIGINAL), ORIGINAL }
|
|
).iterator();
|
|
}
|
|
|
|
@DataProvider(name="putThrows")
|
|
public Iterator<Object[]> putThrows() {
|
|
return Arrays.asList(
|
|
new Object[] { "SimpleSortedMap", load(new SimpleSortedMap<>(), ORIGINAL), ORIGINAL },
|
|
new Object[] { "TreeMap", load(new TreeMap<>(), ORIGINAL), ORIGINAL }
|
|
).iterator();
|
|
}
|
|
|
|
@DataProvider(name="serializable")
|
|
public Iterator<Object[]> serializable() {
|
|
return Arrays.asList(
|
|
new Object[] { "LinkedHashMap", load(new LinkedHashMap<>(), ORIGINAL), ORIGINAL },
|
|
new Object[] { "TreeMap", load(new TreeMap<>(), ORIGINAL), ORIGINAL },
|
|
new Object[] { "UnmodMap", umap(load(new LinkedHashMap<>(), ORIGINAL)), ORIGINAL }
|
|
).iterator();
|
|
}
|
|
|
|
@DataProvider(name="notSerializable")
|
|
public Iterator<Object[]> notSerializable() {
|
|
return Arrays.asList(
|
|
new Object[] { "LinkedHashMap", load(new LinkedHashMap<>(), ORIGINAL).reversed() },
|
|
new Object[] { "UnmodMap", umap(load(new LinkedHashMap<>(), ORIGINAL)).reversed() }
|
|
).iterator();
|
|
}
|
|
|
|
@DataProvider(name="doubleReverse")
|
|
public Iterator<Object[]> doubleReverse() {
|
|
return Arrays.<Object[]>asList(
|
|
new Object[] { "LinkedHashMap", load(new LinkedHashMap<>(), ORIGINAL) }
|
|
).iterator();
|
|
}
|
|
|
|
@DataProvider(name="unmodifiable")
|
|
public Iterator<Object[]> unmodifible() {
|
|
return Arrays.<Object[]>asList(
|
|
new Object[] { "UnmodMap", umap(load(new LinkedHashMap<>(), ORIGINAL)), ORIGINAL },
|
|
new Object[] { "UnmodNav", unav(load(new TreeMap<>(), ORIGINAL)), ORIGINAL },
|
|
new Object[] { "UnmodSorted", usorted(load(new TreeMap<>(), ORIGINAL)), ORIGINAL }
|
|
).iterator();
|
|
}
|
|
|
|
@DataProvider(name="checked")
|
|
public Iterator<Object[]> checked() {
|
|
return Arrays.<Object[]>asList(
|
|
new Object[] { "ChkNav", cknav(load(new TreeMap<>(), ORIGINAL)), ORIGINAL },
|
|
new Object[] { "ChkSorted", cksorted(load(new TreeMap<>(), ORIGINAL)), ORIGINAL }
|
|
).iterator();
|
|
}
|
|
|
|
// mode bit tests
|
|
|
|
boolean reverseMap(int mode) { return (mode & 1) != 0; }
|
|
boolean reverseView(int mode) { return (mode & 2) != 0; }
|
|
boolean callLast(int mode) { return (mode & 4) != 0; }
|
|
|
|
boolean refLast(int mode) { return reverseMap(mode) ^ reverseView(mode) ^ callLast(mode); }
|
|
|
|
/**
|
|
* Generate cases for testing the removeFirst and removeLast methods of map views. For each
|
|
* different map implementation, generate 8 cases from the three bits of the testing mode
|
|
* int value:
|
|
*
|
|
* (bit 1) if true, the backing map is reversed
|
|
* (bit 2) if true, the view is reversed
|
|
* (bit 4) if true, the last element of the view is to be removed, otherwise the first
|
|
*
|
|
* The three bits XORed together (by refLast(), above) indicate (if true) the last
|
|
* or (if false) the first element of the reference entry list is to be removed.
|
|
*
|
|
* @return the generated cases
|
|
*/
|
|
@DataProvider(name="viewRemoves")
|
|
public Iterator<Object[]> viewRemoves() {
|
|
var cases = new ArrayList<Object[]>();
|
|
for (int mode = 0; mode < 8; mode++) {
|
|
cases.addAll(Arrays.asList(
|
|
new Object[] { "LinkedHashMap", mode, load(new LinkedHashMap<>(), ORIGINAL), ORIGINAL },
|
|
new Object[] { "SimpleSortedMap", mode, load(new SimpleSortedMap<>(), ORIGINAL), ORIGINAL },
|
|
new Object[] { "TreeMap", mode, load(new TreeMap<>(), ORIGINAL), ORIGINAL }
|
|
));
|
|
}
|
|
return cases.iterator();
|
|
}
|
|
|
|
@DataProvider(name="emptyViewRemoves")
|
|
public Iterator<Object[]> emptyViewRemoves() {
|
|
var cases = new ArrayList<Object[]>();
|
|
for (int mode = 0; mode < 8; mode++) {
|
|
cases.addAll(Arrays.asList(
|
|
new Object[] { "LinkedHashMap", mode, new LinkedHashMap<>(), List.of() },
|
|
new Object[] { "SimpleSortedMap", mode, new SimpleSortedMap<>(), List.of() },
|
|
new Object[] { "TreeMap", mode, new TreeMap<>(), List.of() }
|
|
));
|
|
}
|
|
return cases.iterator();
|
|
}
|
|
|
|
@DataProvider(name="viewAddThrows")
|
|
public Iterator<Object[]> viewAddThrows() {
|
|
var cases = new ArrayList<Object[]>();
|
|
for (int mode = 0; mode < 8; mode++) {
|
|
cases.addAll(Arrays.asList(
|
|
new Object[] { "LinkedHashMap", mode, load(new LinkedHashMap<>(), ORIGINAL), ORIGINAL },
|
|
new Object[] { "SimpleSortedMap", mode, load(new SimpleSortedMap<>(), ORIGINAL), ORIGINAL },
|
|
new Object[] { "TreeMap", mode, load(new TreeMap<>(), ORIGINAL), ORIGINAL }
|
|
));
|
|
}
|
|
return cases.iterator();
|
|
}
|
|
|
|
@DataProvider(name="nullableEntries")
|
|
public Iterator<Object[]> nullableEntries() {
|
|
return Arrays.asList(
|
|
new Object[] { "firstEntry" },
|
|
new Object[] { "lastEntry" },
|
|
new Object[] { "pollFirstEntry" },
|
|
new Object[] { "pollLastEntry" }
|
|
).iterator();
|
|
}
|
|
|
|
// ========== Assertions ==========
|
|
|
|
/**
|
|
* Basic checks over the contents of a SequencedMap, compared to a reference List of entries,
|
|
* in one direction.
|
|
*
|
|
* @param map the SequencedMap under test
|
|
* @param ref the reference list of entries
|
|
*/
|
|
public void checkContents1(SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> ref) {
|
|
var list1 = new ArrayList<Map.Entry<String, Integer>>();
|
|
map.forEach((k, v) -> list1.add(Map.entry(k, v)));
|
|
assertEquals(list1, ref);
|
|
|
|
assertEquals(map.size(), ref.size());
|
|
assertEquals(map.isEmpty(), ref.isEmpty());
|
|
|
|
for (var e : ref) {
|
|
assertTrue(map.containsKey(e.getKey()));
|
|
assertTrue(map.containsValue(e.getValue()));
|
|
assertEquals(map.get(e.getKey()), e.getValue());
|
|
}
|
|
}
|
|
|
|
public void checkContents(SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> ref) {
|
|
checkContents1(map, ref);
|
|
|
|
var rref = new ArrayList<>(ref);
|
|
Collections.reverse(rref);
|
|
var rmap = map.reversed();
|
|
checkContents1(rmap, rref);
|
|
|
|
var rrmap = rmap.reversed();
|
|
checkContents1(rrmap, ref);
|
|
}
|
|
|
|
/**
|
|
* Check the entrySet, keySet, or values view of a SequencedMap in one direction. The view
|
|
* collection is ordered even though the collection type is not sequenced.
|
|
*
|
|
* @param <T> the element type of the view
|
|
* @param mapView the actual map view
|
|
* @param expElements list of the expected elements
|
|
*/
|
|
public <T> void checkView1(Collection<T> mapView, List<T> expElements) {
|
|
var list1 = new ArrayList<T>();
|
|
for (var k : mapView)
|
|
list1.add(k);
|
|
assertEquals(list1, expElements);
|
|
|
|
var list2 = new ArrayList<T>();
|
|
mapView.forEach(list2::add);
|
|
assertEquals(list2, expElements);
|
|
|
|
var list3 = Arrays.asList(mapView.toArray());
|
|
assertEquals(list3, expElements);
|
|
|
|
var list4 = Arrays.asList(mapView.toArray(new Object[0]));
|
|
assertEquals(list4, expElements);
|
|
|
|
var list5 = Arrays.asList(mapView.toArray(Object[]::new));
|
|
assertEquals(list5, expElements);
|
|
|
|
var list6 = mapView.stream().toList();
|
|
assertEquals(list6, expElements);
|
|
|
|
var list7 = mapView.parallelStream().toList();
|
|
assertEquals(list7, expElements);
|
|
|
|
assertEquals(mapView.size(), expElements.size());
|
|
assertEquals(mapView.isEmpty(), expElements.isEmpty());
|
|
|
|
for (var k : expElements) {
|
|
assertTrue(mapView.contains(k));
|
|
}
|
|
|
|
var it = mapView.iterator();
|
|
if (expElements.isEmpty()) {
|
|
assertFalse(it.hasNext());
|
|
} else {
|
|
assertTrue(it.hasNext());
|
|
assertEquals(it.next(), expElements.get(0));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check the sequenced entrySet, keySet, or values view of a SequencedMap in one direction.
|
|
*
|
|
* @param <T> the element type of the view
|
|
* @param mapView the actual map view
|
|
* @param expElements list of the expected elements
|
|
*/
|
|
public <T> void checkSeqView1(SequencedCollection<T> mapView, List<T> expElements) {
|
|
checkView1(mapView, expElements);
|
|
|
|
if (expElements.isEmpty()) {
|
|
assertThrows(NoSuchElementException.class, () -> mapView.getFirst());
|
|
assertThrows(NoSuchElementException.class, () -> mapView.getLast());
|
|
} else {
|
|
assertEquals(mapView.getFirst(), expElements.get(0));
|
|
assertEquals(mapView.getLast(), expElements.get(expElements.size() - 1));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check the keySet and sequencedKeySet views of a map. It's possible to unify this with
|
|
* the corresponding checks for values and entrySet views, but doing this adds a bunch
|
|
* of generics and method references that tend to obscure more than they help.
|
|
*
|
|
* @param map the SequencedMap under test
|
|
* @param refEntries expected contents of the map
|
|
*/
|
|
public void checkKeySet(SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> refEntries) {
|
|
List<String> refKeys = refEntries.stream().map(Map.Entry::getKey).toList();
|
|
List<String> rrefKeys = new ArrayList<>(refKeys);
|
|
Collections.reverse(rrefKeys);
|
|
SequencedMap<String, Integer> rmap = map.reversed();
|
|
|
|
checkView1(map.keySet(), refKeys);
|
|
checkSeqView1(map.sequencedKeySet(), refKeys);
|
|
checkSeqView1(map.sequencedKeySet().reversed(), rrefKeys);
|
|
|
|
checkView1(rmap.keySet(), rrefKeys);
|
|
checkSeqView1(rmap.sequencedKeySet(), rrefKeys);
|
|
checkSeqView1(rmap.sequencedKeySet().reversed(), refKeys);
|
|
|
|
checkView1(rmap.reversed().keySet(), refKeys);
|
|
checkSeqView1(rmap.reversed().sequencedKeySet(), refKeys);
|
|
checkSeqView1(rmap.reversed().sequencedKeySet().reversed(), rrefKeys);
|
|
|
|
assertEquals(map.keySet().hashCode(), rmap.keySet().hashCode());
|
|
assertEquals(map.keySet().hashCode(), map.sequencedKeySet().hashCode());
|
|
assertEquals(rmap.keySet().hashCode(), rmap.sequencedKeySet().hashCode());
|
|
|
|
// Don't use assertEquals(), as we really want to test the equals() methods.
|
|
assertTrue(map.keySet().equals(map.sequencedKeySet()));
|
|
assertTrue(map.sequencedKeySet().equals(map.keySet()));
|
|
assertTrue(rmap.keySet().equals(map.sequencedKeySet()));
|
|
assertTrue(rmap.sequencedKeySet().equals(map.keySet()));
|
|
assertTrue(map.keySet().equals(rmap.sequencedKeySet()));
|
|
assertTrue(map.sequencedKeySet().equals(rmap.keySet()));
|
|
assertTrue(rmap.keySet().equals(rmap.sequencedKeySet()));
|
|
assertTrue(rmap.sequencedKeySet().equals(rmap.keySet()));
|
|
}
|
|
|
|
/**
|
|
* Check the values and sequencedValues views of a map.
|
|
*
|
|
* @param map the SequencedMap under test
|
|
* @param refEntries expected contents of the map
|
|
*/
|
|
public void checkValues(SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> refEntries) {
|
|
List<Integer> refValues = refEntries.stream().map(Map.Entry::getValue).toList();
|
|
List<Integer> rrefValues = new ArrayList<>(refValues);
|
|
Collections.reverse(rrefValues);
|
|
SequencedMap<String, Integer> rmap = map.reversed();
|
|
|
|
checkView1(map.values(), refValues);
|
|
checkSeqView1(map.sequencedValues(), refValues);
|
|
checkSeqView1(map.sequencedValues().reversed(), rrefValues);
|
|
|
|
checkView1(rmap.values(), rrefValues);
|
|
checkSeqView1(rmap.sequencedValues(), rrefValues);
|
|
checkSeqView1(rmap.sequencedValues().reversed(), refValues);
|
|
|
|
checkView1(rmap.reversed().values(), refValues);
|
|
checkSeqView1(rmap.reversed().sequencedValues(), refValues);
|
|
checkSeqView1(rmap.reversed().sequencedValues().reversed(), rrefValues);
|
|
|
|
// No assertions over hashCode(), as Collection inherits Object.hashCode
|
|
// which is usually but not guaranteed to give unequal results.
|
|
|
|
// It's permissible for an implementation to return the same instance for values()
|
|
// as for sequencedValues(). Either they're the same instance, or they must be
|
|
// unequal, because distinct collections should always be unequal.
|
|
|
|
var v = map.values();
|
|
var sv = map.sequencedValues();
|
|
assertTrue((v == sv) || ! (v.equals(sv) || sv.equals(v)));
|
|
|
|
var rv = rmap.values();
|
|
var rsv = rmap.sequencedValues();
|
|
assertTrue((rv == rsv) || ! (rv.equals(rsv) || rsv.equals(rv)));
|
|
}
|
|
|
|
/**
|
|
* Check the entrySet and sequencedEntrySet views of a map.
|
|
*
|
|
* @param map the SequencedMap under test
|
|
* @param refEntries expected contents of the map
|
|
*/
|
|
public void checkEntrySet(SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> refEntries) {
|
|
List<Map.Entry<String, Integer>> rref = new ArrayList<>(refEntries);
|
|
Collections.reverse(rref);
|
|
SequencedMap<String, Integer> rmap = map.reversed();
|
|
|
|
checkView1(map.entrySet(), refEntries);
|
|
checkSeqView1(map.sequencedEntrySet(), refEntries);
|
|
checkSeqView1(map.sequencedEntrySet().reversed(), rref);
|
|
|
|
checkView1(rmap.entrySet(), rref);
|
|
checkSeqView1(rmap.sequencedEntrySet(), rref);
|
|
checkSeqView1(rmap.sequencedEntrySet().reversed(), refEntries);
|
|
|
|
checkView1(rmap.reversed().entrySet(), refEntries);
|
|
checkSeqView1(rmap.reversed().sequencedEntrySet(), refEntries);
|
|
checkSeqView1(rmap.reversed().sequencedEntrySet().reversed(), rref);
|
|
|
|
assertEquals(map.entrySet().hashCode(), rmap.entrySet().hashCode());
|
|
assertEquals(map.entrySet().hashCode(), map.sequencedEntrySet().hashCode());
|
|
assertEquals(map.sequencedEntrySet().hashCode(), map.entrySet().hashCode());
|
|
|
|
assertTrue(map.entrySet().equals(map.sequencedEntrySet()));
|
|
assertTrue(map.sequencedEntrySet().equals(map.entrySet()));
|
|
assertTrue(rmap.entrySet().equals(map.sequencedEntrySet()));
|
|
assertTrue(rmap.sequencedEntrySet().equals(map.entrySet()));
|
|
assertTrue(map.entrySet().equals(rmap.sequencedEntrySet()));
|
|
assertTrue(map.sequencedEntrySet().equals(rmap.entrySet()));
|
|
assertTrue(rmap.entrySet().equals(rmap.sequencedEntrySet()));
|
|
assertTrue(rmap.sequencedEntrySet().equals(rmap.entrySet()));
|
|
}
|
|
|
|
/**
|
|
* Test attempted modifications to unmodifiable map views. The only mutating operation
|
|
* map views can support is removal.
|
|
*
|
|
* @param <T> element type of the map view
|
|
* @param view the map view
|
|
*/
|
|
public <T> void checkUnmodifiableView(Collection<T> view) {
|
|
assertThrows(UOE, () -> view.clear());
|
|
assertThrows(UOE, () -> { var it = view.iterator(); it.next(); it.remove(); });
|
|
assertThrows(UOE, () -> { var t = view.iterator().next(); view.remove(t); });
|
|
|
|
// TODO these ops should throw unconditionally, but they don't in some implementations
|
|
// assertThrows(UOE, () -> view.removeAll(List.of()));
|
|
// assertThrows(UOE, () -> view.removeIf(x -> false));
|
|
// assertThrows(UOE, () -> view.retainAll(view));
|
|
assertThrows(UOE, () -> view.removeAll(view));
|
|
assertThrows(UOE, () -> view.removeIf(x -> true));
|
|
assertThrows(UOE, () -> view.retainAll(List.of()));
|
|
}
|
|
|
|
/**
|
|
* Test removal methods on unmodifiable sequenced map views.
|
|
*
|
|
* @param <T> element type of the map view
|
|
* @param view the map view
|
|
*/
|
|
public <T> void checkUnmodifiableSeqView(SequencedCollection<T> view) {
|
|
checkUnmodifiableView(view);
|
|
assertThrows(UOE, () -> view.removeFirst());
|
|
assertThrows(UOE, () -> view.removeLast());
|
|
|
|
var rview = view.reversed();
|
|
checkUnmodifiableView(rview);
|
|
assertThrows(UOE, () -> rview.removeFirst());
|
|
assertThrows(UOE, () -> rview.removeLast());
|
|
}
|
|
|
|
public void checkUnmodifiableEntry(SequencedMap<String, Integer> map) {
|
|
assertThrows(UOE, () -> { map.firstEntry().setValue(99); });
|
|
assertThrows(UOE, () -> { map.lastEntry().setValue(99); });
|
|
assertThrows(UOE, () -> { map.sequencedEntrySet().getFirst().setValue(99); });
|
|
assertThrows(UOE, () -> { map.sequencedEntrySet().getLast().setValue(99); });
|
|
assertThrows(UOE, () -> { map.sequencedEntrySet().reversed().getFirst().setValue(99); });
|
|
assertThrows(UOE, () -> { map.sequencedEntrySet().reversed().getLast().setValue(99); });
|
|
}
|
|
|
|
public void checkUnmodifiable1(SequencedMap<String, Integer> map) {
|
|
assertThrows(UOE, () -> map.putFirst("x", 99));
|
|
assertThrows(UOE, () -> map.putLast("x", 99));
|
|
assertThrows(UOE, () -> { map.pollFirstEntry(); });
|
|
assertThrows(UOE, () -> { map.pollLastEntry(); });
|
|
|
|
checkUnmodifiableEntry(map);
|
|
checkUnmodifiableView(map.keySet());
|
|
checkUnmodifiableView(map.values());
|
|
checkUnmodifiableView(map.entrySet());
|
|
checkUnmodifiableSeqView(map.sequencedKeySet());
|
|
checkUnmodifiableSeqView(map.sequencedValues());
|
|
checkUnmodifiableSeqView(map.sequencedEntrySet());
|
|
}
|
|
|
|
public void checkUnmodifiable(SequencedMap<String, Integer> map) {
|
|
checkUnmodifiable1(map);
|
|
checkUnmodifiable1(map.reversed());
|
|
}
|
|
|
|
// The putFirst/putLast operations aren't tested here, because the only instances of
|
|
// checked, sequenced maps are SortedMap and NavigableMap, which don't support them.
|
|
public void checkChecked(SequencedMap<String, Integer> map) {
|
|
SequencedMap<Object, Object> objMap = (SequencedMap<Object, Object>)(SequencedMap)map;
|
|
assertThrows(CCE, () -> { objMap.put(new Object(), 99); });
|
|
assertThrows(CCE, () -> { objMap.put("x", new Object()); });
|
|
assertThrows(CCE, () -> { objMap.sequencedEntrySet().getFirst().setValue(new Object()); });
|
|
assertThrows(CCE, () -> { objMap.sequencedEntrySet().reversed().getFirst().setValue(new Object()); });
|
|
assertThrows(CCE, () -> { objMap.reversed().put(new Object(), 99); });
|
|
assertThrows(CCE, () -> { objMap.reversed().put("x", new Object()); });
|
|
assertThrows(CCE, () -> { objMap.reversed().sequencedEntrySet().getFirst().setValue(new Object()); });
|
|
assertThrows(CCE, () -> { objMap.reversed().sequencedEntrySet().reversed().getFirst().setValue(new Object()); });
|
|
}
|
|
|
|
public void checkEntry(Map.Entry<String, Integer> entry, String key, Integer value) {
|
|
assertEquals(entry.getKey(), key);
|
|
assertEquals(entry.getValue(), value);
|
|
}
|
|
|
|
// ========== Tests ==========
|
|
|
|
@Test(dataProvider="all")
|
|
public void testFundamentals(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> ref) {
|
|
checkContents(map, ref);
|
|
checkEntrySet(map, ref);
|
|
checkKeySet(map, ref);
|
|
checkValues(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="populated")
|
|
public void testFirstEntry(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> ref) {
|
|
assertEquals(map.firstEntry(), ref.get(0));
|
|
assertEquals(map.reversed().firstEntry(), ref.get(ref.size() - 1));
|
|
assertThrows(UOE, () -> { map.firstEntry().setValue(99); });
|
|
assertThrows(UOE, () -> { map.reversed().firstEntry().setValue(99); });
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="populated")
|
|
public void testLastEntry(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> ref) {
|
|
assertEquals(map.lastEntry(), ref.get(ref.size() - 1));
|
|
assertEquals(map.reversed().lastEntry(), ref.get(0));
|
|
assertThrows(UOE, () -> { map.lastEntry().setValue(99); });
|
|
assertThrows(UOE, () -> { map.reversed().lastEntry().setValue(99); });
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="empties")
|
|
public void testEmptyFirstEntry(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> ref) {
|
|
assertNull(map.firstEntry());
|
|
assertNull(map.reversed().firstEntry());
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="empties")
|
|
public void testEmptyLastEntry(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> ref) {
|
|
assertNull(map.lastEntry());
|
|
assertNull(map.reversed().lastEntry());
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="puts")
|
|
public void testPutFirst(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
ref.add(0, Map.entry("x", 99));
|
|
map.putFirst("x", 99);
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="puts")
|
|
public void testPutFirstRev(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
ref.add(Map.entry("x", 99));
|
|
map.reversed().putFirst("x", 99);
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="puts")
|
|
public void testPutLast(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
ref.add(Map.entry("x", 99));
|
|
map.putLast("x", 99);
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="puts")
|
|
public void testPutLastRev(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
ref.add(0, Map.entry("x", 99));
|
|
map.reversed().putLast("x", 99);
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="putUnpositioned")
|
|
public void testUnposPut(String label, boolean rev, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
ref.add(Map.entry("x", 99));
|
|
(rev ? map.reversed() : map).put("x", 99);
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="putUnpositioned")
|
|
public void testUnposPutAll(String label, boolean rev, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
ref.add(Map.entry("x", 99));
|
|
(rev ? map.reversed() : map).putAll(Map.of("x", 99));
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="putUnpositioned")
|
|
public void testUnposPutIfAbsent(String label, boolean rev, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
ref.add(Map.entry("x", 99));
|
|
(rev ? map.reversed() : map).putIfAbsent("x", 99);
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="putUnpositioned")
|
|
public void testUnposCompute(String label, boolean rev, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
ref.add(Map.entry("x", 99));
|
|
(rev ? map.reversed() : map).compute("x", (k, v) -> 99);
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="putUnpositioned")
|
|
public void testUnposComputeIfAbsent(String label, boolean rev, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
ref.add(Map.entry("x", 99));
|
|
(rev ? map.reversed() : map).computeIfAbsent("x", k -> 99);
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="putUnpositioned")
|
|
public void testUnposMerge(String label, boolean rev, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
ref.add(Map.entry("x", 99));
|
|
(rev ? map.reversed() : map).merge("x", 99, /*unused*/ (k, v) -> -1);
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="putThrows")
|
|
public void testPutThrows(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> baseref) {
|
|
assertThrows(UOE, () -> map.putFirst("x", 99));
|
|
assertThrows(UOE, () -> map.putLast("x", 99));
|
|
assertThrows(UOE, () -> map.reversed().putFirst("x", 99));
|
|
assertThrows(UOE, () -> map.reversed().putLast("x", 99));
|
|
checkContents(map, baseref);
|
|
}
|
|
|
|
@Test(dataProvider="polls")
|
|
public void testPollFirst(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
var act = map.pollFirstEntry();
|
|
assertEquals(act, ref.remove(0));
|
|
assertThrows(UOE, () -> { act.setValue(99); });
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="polls")
|
|
public void testPollFirstRev(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
var act = map.reversed().pollFirstEntry();
|
|
assertEquals(act, ref.remove(ref.size() - 1));
|
|
assertThrows(UOE, () -> { act.setValue(99); });
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="polls")
|
|
public void testPollLast(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
var act = map.pollLastEntry();
|
|
assertEquals(act, ref.remove(ref.size() - 1));
|
|
assertThrows(UOE, () -> { act.setValue(99); });
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="polls")
|
|
public void testPollLastRev(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
var act = map.reversed().pollLastEntry();
|
|
assertEquals(act, ref.remove(0));
|
|
assertThrows(UOE, () -> { act.setValue(99); });
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="emptyPolls")
|
|
public void testEmptyPollFirst(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> ref) {
|
|
assertNull(map.pollFirstEntry());
|
|
assertNull(map.reversed().pollFirstEntry());
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="emptyPolls")
|
|
public void testEmptyPollLast(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> ref) {
|
|
assertNull(map.pollLastEntry());
|
|
assertNull(map.reversed().pollLastEntry());
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="serializable")
|
|
public void testSerializable(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> ref)
|
|
throws ClassNotFoundException, IOException
|
|
{
|
|
var baos = new ByteArrayOutputStream();
|
|
try (var oos = new ObjectOutputStream(baos)) {
|
|
oos.writeObject(map);
|
|
}
|
|
|
|
try (var bais = new ByteArrayInputStream(baos.toByteArray());
|
|
var ois = new ObjectInputStream(bais)) {
|
|
var map2 = (SequencedMap<String, Integer>) ois.readObject();
|
|
checkContents(map2, ref);
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider="notSerializable")
|
|
public void testNotSerializable(String label, SequencedMap<String, Integer> map)
|
|
throws ClassNotFoundException, IOException
|
|
{
|
|
var baos = new ByteArrayOutputStream();
|
|
try (var oos = new ObjectOutputStream(baos)) {
|
|
assertThrows(ObjectStreamException.class, () -> oos.writeObject(map));
|
|
}
|
|
}
|
|
|
|
@Test(dataProvider="doubleReverse")
|
|
public void testDoubleReverse(String label, SequencedMap<String, Integer> map) {
|
|
var rrmap = map.reversed().reversed();
|
|
assertSame(rrmap, map);
|
|
}
|
|
|
|
@Test(dataProvider="unmodifiable")
|
|
public void testUnmodifiable(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> ref) {
|
|
checkUnmodifiable(map);
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
@Test(dataProvider="checked")
|
|
public void testChecked(String label, SequencedMap<String, Integer> map, List<Map.Entry<String, Integer>> ref) {
|
|
checkChecked(map);
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
/**
|
|
* Test that a removal from the sequenedKeySet view is properly reflected in the original
|
|
* backing map. The mode value indicates whether the backing map is reversed, whether the
|
|
* sequencedKeySet view is reversed, and whether the removeFirst or removeLast is called
|
|
* on the view. See the viewRemoves() dataProvider for details.
|
|
*
|
|
* @param label the implementation label
|
|
* @param mode reversed and first/last modes
|
|
* @param map the original map instance
|
|
* @param baseref reference contents of the original map
|
|
*/
|
|
@Test(dataProvider="viewRemoves")
|
|
public void testKeySetRemoves(String label,
|
|
int mode,
|
|
SequencedMap<String, Integer> map,
|
|
List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
var exp = (refLast(mode) ? ref.remove(ref.size() - 1) : ref.remove(0)).getKey();
|
|
var tempmap = reverseMap(mode) ? map.reversed() : map;
|
|
var keySet = reverseView(mode) ? tempmap.sequencedKeySet().reversed() : tempmap.sequencedKeySet();
|
|
var act = callLast(mode) ? keySet.removeLast() : keySet.removeFirst();
|
|
assertEquals(act, exp);
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
// As above, but for the sequencedValues view.
|
|
@Test(dataProvider="viewRemoves")
|
|
public void testValuesRemoves(String label,
|
|
int mode,
|
|
SequencedMap<String, Integer> map,
|
|
List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
var exp = (refLast(mode) ? ref.remove(ref.size() - 1) : ref.remove(0)).getValue();
|
|
var tempmap = reverseMap(mode) ? map.reversed() : map;
|
|
var values = reverseView(mode) ? tempmap.sequencedValues().reversed() : tempmap.sequencedValues();
|
|
var act = callLast(mode) ? values.removeLast() : values.removeFirst();
|
|
assertEquals(act, exp);
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
// As above, but for the sequencedEntrySet view.
|
|
@Test(dataProvider="viewRemoves")
|
|
public void testEntrySetRemoves(String label,
|
|
int mode,
|
|
SequencedMap<String, Integer> map,
|
|
List<Map.Entry<String, Integer>> baseref) {
|
|
var ref = new ArrayList<>(baseref);
|
|
var exp = refLast(mode) ? ref.remove(ref.size() - 1) : ref.remove(0);
|
|
var tempmap = reverseMap(mode) ? map.reversed() : map;
|
|
var entrySet = reverseView(mode) ? tempmap.sequencedEntrySet().reversed() : tempmap.sequencedEntrySet();
|
|
var act = callLast(mode) ? entrySet.removeLast() : entrySet.removeFirst();
|
|
assertEquals(act, exp);
|
|
checkContents(map, ref);
|
|
}
|
|
|
|
// As above, but for the sequencedKeySet of an empty map.
|
|
@Test(dataProvider="emptyViewRemoves")
|
|
public void testEmptyKeySetRemoves(String label,
|
|
int mode,
|
|
SequencedMap<String, Integer> map,
|
|
List<Map.Entry<String, Integer>> baseref) {
|
|
var tempmap = reverseMap(mode) ? map.reversed() : map;
|
|
var keySet = reverseView(mode) ? tempmap.sequencedKeySet().reversed() : tempmap.sequencedKeySet();
|
|
if (callLast(mode))
|
|
assertThrows(NSEE, () -> keySet.removeLast());
|
|
else
|
|
assertThrows(NSEE, () -> keySet.removeFirst());
|
|
checkContents(map, baseref);
|
|
|
|
}
|
|
|
|
// As above, but for the sequencedValues view.
|
|
@Test(dataProvider="emptyViewRemoves")
|
|
public void testEmptyValuesRemoves(String label,
|
|
int mode,
|
|
SequencedMap<String, Integer> map,
|
|
List<Map.Entry<String, Integer>> baseref) {
|
|
var tempmap = reverseMap(mode) ? map.reversed() : map;
|
|
var values = reverseView(mode) ? tempmap.sequencedValues().reversed() : tempmap.sequencedValues();
|
|
if (callLast(mode))
|
|
assertThrows(NSEE, () -> values.removeLast());
|
|
else
|
|
assertThrows(NSEE, () -> values.removeFirst());
|
|
checkContents(map, baseref);
|
|
}
|
|
|
|
// As above, but for the sequencedEntrySet view.
|
|
@Test(dataProvider="emptyViewRemoves")
|
|
public void testEmptyEntrySetRemoves(String label,
|
|
int mode,
|
|
SequencedMap<String, Integer> map,
|
|
List<Map.Entry<String, Integer>> baseref) {
|
|
var tempmap = reverseMap(mode) ? map.reversed() : map;
|
|
var entrySet = reverseView(mode) ? tempmap.sequencedEntrySet().reversed() : tempmap.sequencedEntrySet();
|
|
if (callLast(mode))
|
|
assertThrows(NSEE, () -> entrySet.removeLast());
|
|
else
|
|
assertThrows(NSEE, () -> entrySet.removeFirst());
|
|
checkContents(map, baseref);
|
|
}
|
|
|
|
// Test that addFirst/addLast on the sequencedKeySetView throw UnsupportedOperationException.
|
|
@Test(dataProvider="viewAddThrows")
|
|
public void testKeySetAddThrows(String label,
|
|
int mode,
|
|
SequencedMap<String, Integer> map,
|
|
List<Map.Entry<String, Integer>> baseref) {
|
|
var tempmap = reverseMap(mode) ? map.reversed() : map;
|
|
var keySet = reverseView(mode) ? tempmap.sequencedKeySet().reversed() : tempmap.sequencedKeySet();
|
|
if (callLast(mode))
|
|
assertThrows(UOE, () -> keySet.addLast("x"));
|
|
else
|
|
assertThrows(UOE, () -> keySet.addFirst("x"));
|
|
checkContents(map, baseref);
|
|
}
|
|
|
|
// As above, but for the sequencedValues view.
|
|
@Test(dataProvider="viewAddThrows")
|
|
public void testValuesAddThrows(String label,
|
|
int mode,
|
|
SequencedMap<String, Integer> map,
|
|
List<Map.Entry<String, Integer>> baseref) {
|
|
var tempmap = reverseMap(mode) ? map.reversed() : map;
|
|
var values = reverseView(mode) ? tempmap.sequencedValues().reversed() : tempmap.sequencedValues();
|
|
if (callLast(mode))
|
|
assertThrows(UOE, () -> values.addLast(99));
|
|
else
|
|
assertThrows(UOE, () -> values.addFirst(99));
|
|
checkContents(map, baseref);
|
|
}
|
|
|
|
// As above, but for the sequencedEntrySet view.
|
|
@Test(dataProvider="viewAddThrows")
|
|
public void testEntrySetAddThrows(String label,
|
|
int mode,
|
|
SequencedMap<String, Integer> map,
|
|
List<Map.Entry<String, Integer>> baseref) {
|
|
var tempmap = reverseMap(mode) ? map.reversed() : map;
|
|
var entrySet = reverseView(mode) ? tempmap.sequencedEntrySet().reversed() : tempmap.sequencedEntrySet();
|
|
if (callLast(mode))
|
|
assertThrows(UOE, () -> entrySet.addLast(Map.entry("x", 99)));
|
|
else
|
|
assertThrows(UOE, () -> entrySet.addFirst(Map.entry("x", 99)));
|
|
checkContents(map, baseref);
|
|
}
|
|
|
|
@Test(dataProvider="nullableEntries")
|
|
public void testNullableKeyValue(String mode) {
|
|
// TODO this relies on LHM to inherit SequencedMap default
|
|
// methods which are actually being tested here.
|
|
SequencedMap<String, Integer> map = new LinkedHashMap<>();
|
|
map.put(null, 1);
|
|
map.put("two", null);
|
|
|
|
switch (mode) {
|
|
case "firstEntry" -> checkEntry(map.firstEntry(), null, 1);
|
|
case "lastEntry" -> checkEntry(map.lastEntry(), "two", null);
|
|
case "pollFirstEntry" -> checkEntry(map.pollFirstEntry(), null, 1);
|
|
case "pollLastEntry" -> checkEntry(map.pollLastEntry(), "two", null);
|
|
default -> throw new AssertionError("illegal mode " + mode);
|
|
}
|
|
}
|
|
}
|