public void testNefariousMapPutAll() {
Map<String, Integer> map = Maps.newLinkedHashMap();
Map<String, Integer> constrained = MapConstraints.constrainedMap(map, TEST_CONSTRAINT);
Map<String, Integer> onceIterable = onceIterableMap("foo", 1);
constrained.putAll(onceIterable);
assertEquals((Integer) 1, constrained.get("foo"));
}
public void testConstrainedMapIllegal() {
Map<String, Integer> map = Maps.newLinkedHashMap();
Map<String, Integer> constrained = MapConstraints.constrainedMap(map, TEST_CONSTRAINT);
try {
constrained.put(TEST_KEY, TEST_VALUE);
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.put("baz", TEST_VALUE);
fail("TestValueException expected");
} catch (TestValueException expected) {
}
try {
constrained.put(TEST_KEY, 3);
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.putAll(ImmutableMap.of("baz", 3, TEST_KEY, 4));
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
assertEquals(Collections.emptySet(), map.entrySet());
assertEquals(Collections.emptySet(), constrained.entrySet());
}
public void testConstrainedBiMapLegal() {
BiMap<String, Integer> map =
new AbstractBiMap<String, Integer>(
Maps.<String, Integer>newLinkedHashMap(), Maps.<Integer, String>newLinkedHashMap()) {};
BiMap<String, Integer> constrained = MapConstraints.constrainedBiMap(map, TEST_CONSTRAINT);
map.put(TEST_KEY, TEST_VALUE);
constrained.put("foo", 1);
map.putAll(ImmutableMap.of("bar", 2));
constrained.putAll(ImmutableMap.of("baz", 3));
assertTrue(map.equals(constrained));
assertTrue(constrained.equals(map));
assertEquals(map.entrySet(), constrained.entrySet());
assertEquals(map.keySet(), constrained.keySet());
assertEquals(map.values(), constrained.values());
assertEquals(map.toString(), constrained.toString());
assertEquals(map.hashCode(), constrained.hashCode());
ASSERT
.that(map.entrySet())
.has()
.allOf(
Maps.immutableEntry(TEST_KEY, TEST_VALUE),
Maps.immutableEntry("foo", 1),
Maps.immutableEntry("bar", 2),
Maps.immutableEntry("baz", 3))
.inOrder();
}
public void testConstrainedMultimapQueue() {
Multimap<String, Integer> multimap =
Multimaps.newMultimap(new HashMap<String, Collection<Integer>>(), new QueueSupplier());
Multimap<String, Integer> constrained =
MapConstraints.constrainedMultimap(multimap, TEST_CONSTRAINT);
constrained.put("foo", 1);
assertTrue(constrained.get("foo").contains(1));
assertTrue(multimap.get("foo").contains(1));
try {
constrained.put(TEST_KEY, 1);
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.put("foo", TEST_VALUE);
fail("TestValueException expected");
} catch (TestValueException expected) {
}
try {
constrained.get("foo").add(TEST_VALUE);
fail("TestKeyException expected");
} catch (TestValueException expected) {
}
try {
constrained.get(TEST_KEY).add(1);
fail("TestValueException expected");
} catch (TestKeyException expected) {
}
assertEquals(1, constrained.size());
assertEquals(1, multimap.size());
}
public void testConstrainedMapLegal() {
Map<String, Integer> map = Maps.newLinkedHashMap();
Map<String, Integer> constrained = MapConstraints.constrainedMap(map, TEST_CONSTRAINT);
map.put(TEST_KEY, TEST_VALUE);
constrained.put("foo", 1);
map.putAll(ImmutableMap.of("bar", 2));
constrained.putAll(ImmutableMap.of("baz", 3));
assertTrue(map.equals(constrained));
assertTrue(constrained.equals(map));
assertEquals(map.entrySet(), constrained.entrySet());
assertEquals(map.keySet(), constrained.keySet());
assertEquals(HashMultiset.create(map.values()), HashMultiset.create(constrained.values()));
assertFalse(map.values() instanceof Serializable);
assertEquals(map.toString(), constrained.toString());
assertEquals(map.hashCode(), constrained.hashCode());
ASSERT
.that(map.entrySet())
.has()
.allOf(
Maps.immutableEntry(TEST_KEY, TEST_VALUE),
Maps.immutableEntry("foo", 1),
Maps.immutableEntry("bar", 2),
Maps.immutableEntry("baz", 3))
.inOrder();
}
public void testConstrainedTypePreservingSet() {
SetMultimap<String, Integer> multimap =
MapConstraints.constrainedSetMultimap(
LinkedHashMultimap.<String, Integer>create(), TEST_CONSTRAINT);
multimap.put("foo", 1);
Map.Entry<String, Collection<Integer>> entry = multimap.asMap().entrySet().iterator().next();
assertTrue(entry.getValue() instanceof Set);
}
public void testNefariousMultimapPutAllMultimap() {
Multimap<String, Integer> multimap = LinkedListMultimap.create();
Multimap<String, Integer> constrained =
MapConstraints.constrainedMultimap(multimap, TEST_CONSTRAINT);
Multimap<String, Integer> onceIterable = Multimaps.forMap(onceIterableMap("foo", 1));
constrained.putAll(onceIterable);
assertEquals(ImmutableList.of(1), constrained.get("foo"));
}
public void testNefariousMultimapGetAddAll() {
Multimap<String, Integer> multimap = LinkedListMultimap.create();
Multimap<String, Integer> constrained =
MapConstraints.constrainedMultimap(multimap, TEST_CONSTRAINT);
Collection<Integer> onceIterable = ConstraintsTest.onceIterableCollection(1);
constrained.get("foo").addAll(onceIterable);
assertEquals(ImmutableList.of(1), constrained.get("foo"));
}
public void testConstrainedTypePreservingRandomAccessList() {
ListMultimap<String, Integer> multimap =
MapConstraints.constrainedListMultimap(
ArrayListMultimap.<String, Integer>create(), TEST_CONSTRAINT);
multimap.put("foo", 1);
Map.Entry<String, Collection<Integer>> entry = multimap.asMap().entrySet().iterator().next();
assertTrue(entry.getValue() instanceof List);
assertFalse(multimap.entries() instanceof Set);
assertTrue(multimap.get("foo") instanceof RandomAccess);
}
public void testPutWithAllowedKeyForbiddenValue() {
BiMap<String, String> map =
MapConstraints.constrainedBiMap(HashBiMap.<String, String>create(), TEST_CONSTRAINT);
try {
map.put("allowed", TEST_VALUE);
fail("Expected IllegalArgumentException");
} catch (IllegalArgumentException expected) {
// success
}
}
@Override
protected BiMap<String, String> create(Entry<String, String>[] entries) {
BiMap<String, String> bimap =
MapConstraints.constrainedBiMap(HashBiMap.<String, String>create(), TEST_CONSTRAINT);
for (Entry<String, String> entry : entries) {
checkArgument(!bimap.containsKey(entry.getKey()));
bimap.put(entry.getKey(), entry.getValue());
}
return bimap;
}
public void testMapEntrySetContainsNefariousEntry() {
Map<String, Integer> map = Maps.newTreeMap();
Map<String, Integer> constrained = MapConstraints.constrainedMap(map, TEST_CONSTRAINT);
map.put("foo", 1);
Map.Entry<String, Integer> nefariousEntry = nefariousMapEntry(TEST_KEY, TEST_VALUE);
Set<Map.Entry<String, Integer>> entries = constrained.entrySet();
assertFalse(entries.contains(nefariousEntry));
assertFalse(map.containsValue(TEST_VALUE));
assertFalse(entries.containsAll(Collections.singleton(nefariousEntry)));
assertFalse(map.containsValue(TEST_VALUE));
}
public void testMultimapEntriesRemoveNefariousEntry() {
Multimap<String, Integer> multimap = LinkedListMultimap.create();
Multimap<String, Integer> constrained =
MapConstraints.constrainedMultimap(multimap, TEST_CONSTRAINT);
multimap.put("foo", 1);
Map.Entry<String, Integer> nefariousEntry = nefariousMapEntry(TEST_KEY, TEST_VALUE);
Collection<Map.Entry<String, Integer>> entries = constrained.entries();
assertFalse(entries.remove(nefariousEntry));
assertFalse(multimap.containsValue(TEST_VALUE));
assertFalse(entries.removeAll(Collections.singleton(nefariousEntry)));
assertFalse(multimap.containsValue(TEST_VALUE));
}
public void testConstrainedTypePreservingSortedSet() {
Comparator<Integer> comparator = Collections.reverseOrder();
SortedSetMultimap<String, Integer> delegate =
TreeMultimap.create(Ordering.<String>natural(), comparator);
SortedSetMultimap<String, Integer> multimap =
MapConstraints.constrainedSortedSetMultimap(delegate, TEST_CONSTRAINT);
multimap.put("foo", 1);
Map.Entry<String, Collection<Integer>> entry = multimap.asMap().entrySet().iterator().next();
assertTrue(entry.getValue() instanceof SortedSet);
assertSame(comparator, multimap.valueComparator());
assertSame(comparator, multimap.get("foo").comparator());
}
public void testConstrainedMultimapLegal() {
Multimap<String, Integer> multimap = LinkedListMultimap.create();
Multimap<String, Integer> constrained =
MapConstraints.constrainedMultimap(multimap, TEST_CONSTRAINT);
multimap.put(TEST_KEY, TEST_VALUE);
constrained.put("foo", 1);
multimap.get("bar").add(2);
constrained.get("baz").add(3);
multimap.get("qux").addAll(Arrays.asList(4));
constrained.get("zig").addAll(Arrays.asList(5));
multimap.putAll("zag", Arrays.asList(6));
constrained.putAll("bee", Arrays.asList(7));
multimap.putAll(new ImmutableMultimap.Builder<String, Integer>().put("bim", 8).build());
constrained.putAll(new ImmutableMultimap.Builder<String, Integer>().put("bop", 9).build());
multimap.putAll(new ImmutableMultimap.Builder<String, Integer>().put("dig", 10).build());
constrained.putAll(new ImmutableMultimap.Builder<String, Integer>().put("dag", 11).build());
assertTrue(multimap.equals(constrained));
assertTrue(constrained.equals(multimap));
ASSERT
.that(ImmutableList.copyOf(multimap.entries()))
.is(ImmutableList.copyOf(constrained.entries()));
ASSERT.that(constrained.asMap().get("foo")).has().item(1);
assertNull(constrained.asMap().get("missing"));
assertEquals(multimap.asMap(), constrained.asMap());
assertEquals(multimap.values(), constrained.values());
assertEquals(multimap.keys(), constrained.keys());
assertEquals(multimap.keySet(), constrained.keySet());
assertEquals(multimap.toString(), constrained.toString());
assertEquals(multimap.hashCode(), constrained.hashCode());
ASSERT
.that(multimap.entries())
.has()
.allOf(
Maps.immutableEntry(TEST_KEY, TEST_VALUE),
Maps.immutableEntry("foo", 1),
Maps.immutableEntry("bar", 2),
Maps.immutableEntry("baz", 3),
Maps.immutableEntry("qux", 4),
Maps.immutableEntry("zig", 5),
Maps.immutableEntry("zag", 6),
Maps.immutableEntry("bee", 7),
Maps.immutableEntry("bim", 8),
Maps.immutableEntry("bop", 9),
Maps.immutableEntry("dig", 10),
Maps.immutableEntry("dag", 11))
.inOrder();
assertFalse(constrained.asMap().values() instanceof Serializable);
Iterator<Collection<Integer>> iterator = constrained.asMap().values().iterator();
iterator.next();
iterator.next().add(12);
assertTrue(multimap.containsEntry("foo", 12));
}
public void testMultimapAsMapEntriesContainsNefariousEntry() {
Multimap<String, Integer> multimap = LinkedListMultimap.create();
Multimap<String, Integer> constrained =
MapConstraints.constrainedMultimap(multimap, TEST_CONSTRAINT);
multimap.put("foo", 1);
Map.Entry<String, ? extends Collection<Integer>> nefariousEntry =
nefariousMapEntry(TEST_KEY, Collections.singleton(TEST_VALUE));
Set<Map.Entry<String, Collection<Integer>>> entries = constrained.asMap().entrySet();
assertFalse(entries.contains(nefariousEntry));
assertFalse(multimap.containsValue(TEST_VALUE));
assertFalse(entries.containsAll(Collections.singleton(nefariousEntry)));
assertFalse(multimap.containsValue(TEST_VALUE));
}
public void testMapEntrySetToArray() {
Map<String, Integer> map = Maps.newLinkedHashMap();
Map<String, Integer> constrained = MapConstraints.constrainedMap(map, TEST_CONSTRAINT);
map.put("foo", 1);
@SuppressWarnings("unchecked")
Map.Entry<String, Integer> entry = (Map.Entry) constrained.entrySet().toArray()[0];
try {
entry.setValue(TEST_VALUE);
fail("TestValueException expected");
} catch (TestValueException expected) {
}
assertFalse(map.containsValue(TEST_VALUE));
}
public void testMultimapAsMapValuesToArray() {
Multimap<String, Integer> multimap = LinkedListMultimap.create();
Multimap<String, Integer> constrained =
MapConstraints.constrainedMultimap(multimap, TEST_CONSTRAINT);
multimap.put("foo", 1);
@SuppressWarnings("unchecked")
Collection<Integer> collection =
(Collection<Integer>) constrained.asMap().values().toArray()[0];
try {
collection.add(TEST_VALUE);
fail("TestValueException expected");
} catch (TestValueException expected) {
}
assertFalse(multimap.containsValue(TEST_VALUE));
}
public void testConstrainedBiMapIllegal() {
BiMap<String, Integer> map =
new AbstractBiMap<String, Integer>(
Maps.<String, Integer>newLinkedHashMap(), Maps.<Integer, String>newLinkedHashMap()) {};
BiMap<String, Integer> constrained = MapConstraints.constrainedBiMap(map, TEST_CONSTRAINT);
try {
constrained.put(TEST_KEY, TEST_VALUE);
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.put("baz", TEST_VALUE);
fail("TestValueException expected");
} catch (TestValueException expected) {
}
try {
constrained.put(TEST_KEY, 3);
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.putAll(ImmutableMap.of("baz", 3, TEST_KEY, 4));
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.forcePut(TEST_KEY, 3);
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.inverse().forcePut(TEST_VALUE, "baz");
fail("TestValueException expected");
} catch (TestValueException expected) {
}
try {
constrained.inverse().forcePut(3, TEST_KEY);
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
assertEquals(Collections.emptySet(), map.entrySet());
assertEquals(Collections.emptySet(), constrained.entrySet());
}
public void testNotNull() {
MapConstraint<Object, Object> constraint = MapConstraints.notNull();
constraint.checkKeyValue("foo", 1);
assertEquals("Not null", constraint.toString());
try {
constraint.checkKeyValue(null, 1);
fail("NullPointerException expected");
} catch (NullPointerException expected) {
}
try {
constraint.checkKeyValue("foo", null);
fail("NullPointerException expected");
} catch (NullPointerException expected) {
}
try {
constraint.checkKeyValue(null, null);
fail("NullPointerException expected");
} catch (NullPointerException expected) {
}
}
public void testMultimapAsMapEntriesToArray() {
Multimap<String, Integer> multimap = LinkedListMultimap.create();
Multimap<String, Integer> constrained =
MapConstraints.constrainedMultimap(multimap, TEST_CONSTRAINT);
multimap.put("foo", 1);
@SuppressWarnings("unchecked")
Map.Entry<String, Collection<Integer>> entry =
(Map.Entry<String, Collection<Integer>>) constrained.asMap().entrySet().toArray()[0];
try {
entry.setValue(Collections.<Integer>emptySet());
fail("UnsupportedOperationException expected");
} catch (UnsupportedOperationException expected) {
}
try {
entry.getValue().add(TEST_VALUE);
fail("TestValueException expected");
} catch (TestValueException expected) {
}
assertFalse(multimap.containsValue(TEST_VALUE));
}
@SuppressWarnings("unchecked")
public void testConstrainedMultimapIllegal() {
Multimap<String, Integer> multimap = LinkedListMultimap.create();
Multimap<String, Integer> constrained =
MapConstraints.constrainedMultimap(multimap, TEST_CONSTRAINT);
try {
constrained.put(TEST_KEY, 1);
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.put("foo", TEST_VALUE);
fail("TestValueException expected");
} catch (TestValueException expected) {
}
try {
constrained.put(TEST_KEY, TEST_VALUE);
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.get(TEST_KEY).add(1);
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.get("foo").add(TEST_VALUE);
fail("TestValueException expected");
} catch (TestValueException expected) {
}
try {
constrained.get(TEST_KEY).add(TEST_VALUE);
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.get(TEST_KEY).addAll(Arrays.asList(1));
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.get("foo").addAll(Arrays.asList(1, TEST_VALUE));
fail("TestValueException expected");
} catch (TestValueException expected) {
}
try {
constrained.get(TEST_KEY).addAll(Arrays.asList(1, TEST_VALUE));
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.putAll(TEST_KEY, Arrays.asList(1));
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.putAll("foo", Arrays.asList(1, TEST_VALUE));
fail("TestValueException expected");
} catch (TestValueException expected) {
}
try {
constrained.putAll(TEST_KEY, Arrays.asList(1, TEST_VALUE));
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.putAll(
new ImmutableMultimap.Builder<String, Integer>().put(TEST_KEY, 2).put("foo", 1).build());
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.putAll(
new ImmutableMultimap.Builder<String, Integer>()
.put("bar", TEST_VALUE)
.put("foo", 1)
.build());
fail("TestValueException expected");
} catch (TestValueException expected) {
}
try {
constrained.putAll(
new ImmutableMultimap.Builder<String, Integer>()
.put(TEST_KEY, TEST_VALUE)
.put("foo", 1)
.build());
fail("TestKeyException expected");
} catch (TestKeyException expected) {
}
try {
constrained.entries().add(Maps.immutableEntry(TEST_KEY, 1));
fail("UnsupportedOperationException expected");
} catch (UnsupportedOperationException expected) {
}
try {
constrained
.entries()
.addAll(Arrays.asList(Maps.immutableEntry("foo", 1), Maps.immutableEntry(TEST_KEY, 2)));
fail("UnsupportedOperationException expected");
} catch (UnsupportedOperationException expected) {
}
assertTrue(multimap.isEmpty());
assertTrue(constrained.isEmpty());
constrained.put("foo", 1);
try {
constrained.asMap().get("foo").add(TEST_VALUE);
fail("TestValueException expected");
} catch (TestValueException expected) {
}
try {
constrained.asMap().values().iterator().next().add(TEST_VALUE);
fail("TestValueException expected");
} catch (TestValueException expected) {
}
try {
((Collection<Integer>) constrained.asMap().values().toArray()[0]).add(TEST_VALUE);
fail("TestValueException expected");
} catch (TestValueException expected) {
}
ASSERT
.that(ImmutableList.copyOf(multimap.entries()))
.is(ImmutableList.copyOf(constrained.entries()));
assertEquals(multimap.asMap(), constrained.asMap());
assertEquals(multimap.values(), constrained.values());
assertEquals(multimap.keys(), constrained.keys());
assertEquals(multimap.keySet(), constrained.keySet());
assertEquals(multimap.toString(), constrained.toString());
assertEquals(multimap.hashCode(), constrained.hashCode());
}