Home | History | Annotate | Download | only in collect
      1 /*
      2  * Copyright (C) 2007 The Guava Authors
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  * http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.google.common.collect;
     18 
     19 import static com.google.common.collect.testing.Helpers.nefariousMapEntry;
     20 import static org.junit.contrib.truth.Truth.ASSERT;
     21 
     22 import com.google.common.annotations.GwtCompatible;
     23 import com.google.common.annotations.GwtIncompatible;
     24 import com.google.common.base.Supplier;
     25 import com.google.common.testing.SerializableTester;
     26 
     27 import junit.framework.TestCase;
     28 
     29 import java.io.Serializable;
     30 import java.util.AbstractMap;
     31 import java.util.Arrays;
     32 import java.util.Collection;
     33 import java.util.Collections;
     34 import java.util.Comparator;
     35 import java.util.HashMap;
     36 import java.util.Iterator;
     37 import java.util.LinkedList;
     38 import java.util.List;
     39 import java.util.Map;
     40 import java.util.Queue;
     41 import java.util.RandomAccess;
     42 import java.util.Set;
     43 import java.util.SortedSet;
     44 
     45 /**
     46  * Tests for {@code MapConstraints}.
     47  *
     48  * @author Mike Bostock
     49  * @author Jared Levy
     50  */
     51 @GwtCompatible(emulated = true)
     52 public class MapConstraintsTest extends TestCase {
     53 
     54   private static final String TEST_KEY = "test";
     55 
     56   private static final Integer TEST_VALUE = 42;
     57 
     58   static final class TestKeyException extends IllegalArgumentException {
     59     private static final long serialVersionUID = 0;
     60   }
     61 
     62   static final class TestValueException extends IllegalArgumentException {
     63     private static final long serialVersionUID = 0;
     64   }
     65 
     66   static final MapConstraint<String, Integer> TEST_CONSTRAINT
     67       = new TestConstraint();
     68 
     69   private static final class TestConstraint
     70       implements MapConstraint<String, Integer>, Serializable {
     71     @Override
     72     public void checkKeyValue(String key, Integer value) {
     73       if (TEST_KEY.equals(key)) {
     74         throw new TestKeyException();
     75       }
     76       if (TEST_VALUE.equals(value)) {
     77         throw new TestValueException();
     78       }
     79     }
     80     private static final long serialVersionUID = 0;
     81   }
     82 
     83   public void testNotNull() {
     84     MapConstraint<Object, Object> constraint = MapConstraints.notNull();
     85     constraint.checkKeyValue("foo", 1);
     86     assertEquals("Not null", constraint.toString());
     87     try {
     88       constraint.checkKeyValue(null, 1);
     89       fail("NullPointerException expected");
     90     } catch (NullPointerException expected) {}
     91     try {
     92       constraint.checkKeyValue("foo", null);
     93       fail("NullPointerException expected");
     94     } catch (NullPointerException expected) {}
     95     try {
     96       constraint.checkKeyValue(null, null);
     97       fail("NullPointerException expected");
     98     } catch (NullPointerException expected) {}
     99   }
    100 
    101   public void testConstrainedMapLegal() {
    102     Map<String, Integer> map = Maps.newLinkedHashMap();
    103     Map<String, Integer> constrained = MapConstraints.constrainedMap(
    104         map, TEST_CONSTRAINT);
    105     map.put(TEST_KEY, TEST_VALUE);
    106     constrained.put("foo", 1);
    107     map.putAll(ImmutableMap.of("bar", 2));
    108     constrained.putAll(ImmutableMap.of("baz", 3));
    109     assertTrue(map.equals(constrained));
    110     assertTrue(constrained.equals(map));
    111     assertEquals(map.entrySet(), constrained.entrySet());
    112     assertEquals(map.keySet(), constrained.keySet());
    113     assertEquals(HashMultiset.create(map.values()),
    114         HashMultiset.create(constrained.values()));
    115     assertFalse(map.values() instanceof Serializable);
    116     assertEquals(map.toString(), constrained.toString());
    117     assertEquals(map.hashCode(), constrained.hashCode());
    118     ASSERT.that(map.entrySet()).hasContentsInOrder(
    119         Maps.immutableEntry(TEST_KEY, TEST_VALUE),
    120         Maps.immutableEntry("foo", 1),
    121         Maps.immutableEntry("bar", 2),
    122         Maps.immutableEntry("baz", 3));
    123   }
    124 
    125   public void testConstrainedMapIllegal() {
    126     Map<String, Integer> map = Maps.newLinkedHashMap();
    127     Map<String, Integer> constrained = MapConstraints.constrainedMap(
    128         map, TEST_CONSTRAINT);
    129     try {
    130       constrained.put(TEST_KEY, TEST_VALUE);
    131       fail("TestKeyException expected");
    132     } catch (TestKeyException expected) {}
    133     try {
    134       constrained.put("baz", TEST_VALUE);
    135       fail("TestValueException expected");
    136     } catch (TestValueException expected) {}
    137     try {
    138       constrained.put(TEST_KEY, 3);
    139       fail("TestKeyException expected");
    140     } catch (TestKeyException expected) {}
    141     try {
    142       constrained.putAll(ImmutableMap.of("baz", 3, TEST_KEY, 4));
    143       fail("TestKeyException expected");
    144     } catch (TestKeyException expected) {}
    145     assertEquals(Collections.emptySet(), map.entrySet());
    146     assertEquals(Collections.emptySet(), constrained.entrySet());
    147   }
    148 
    149   public void testConstrainedBiMapLegal() {
    150     BiMap<String, Integer> map = new AbstractBiMap<String, Integer>(
    151         Maps.<String, Integer>newLinkedHashMap(),
    152         Maps.<Integer, String>newLinkedHashMap()) {};
    153     BiMap<String, Integer> constrained = MapConstraints.constrainedBiMap(
    154         map, TEST_CONSTRAINT);
    155     map.put(TEST_KEY, TEST_VALUE);
    156     constrained.put("foo", 1);
    157     map.putAll(ImmutableMap.of("bar", 2));
    158     constrained.putAll(ImmutableMap.of("baz", 3));
    159     assertTrue(map.equals(constrained));
    160     assertTrue(constrained.equals(map));
    161     assertEquals(map.entrySet(), constrained.entrySet());
    162     assertEquals(map.keySet(), constrained.keySet());
    163     assertEquals(map.values(), constrained.values());
    164     assertEquals(map.toString(), constrained.toString());
    165     assertEquals(map.hashCode(), constrained.hashCode());
    166     ASSERT.that(map.entrySet()).hasContentsInOrder(
    167         Maps.immutableEntry(TEST_KEY, TEST_VALUE),
    168         Maps.immutableEntry("foo", 1),
    169         Maps.immutableEntry("bar", 2),
    170         Maps.immutableEntry("baz", 3));
    171   }
    172 
    173   public void testConstrainedBiMapIllegal() {
    174     BiMap<String, Integer> map = new AbstractBiMap<String, Integer>(
    175         Maps.<String, Integer>newLinkedHashMap(),
    176         Maps.<Integer, String>newLinkedHashMap()) {};
    177     BiMap<String, Integer> constrained = MapConstraints.constrainedBiMap(
    178         map, TEST_CONSTRAINT);
    179     try {
    180       constrained.put(TEST_KEY, TEST_VALUE);
    181       fail("TestKeyException expected");
    182     } catch (TestKeyException expected) {}
    183     try {
    184       constrained.put("baz", TEST_VALUE);
    185       fail("TestValueException expected");
    186     } catch (TestValueException expected) {}
    187     try {
    188       constrained.put(TEST_KEY, 3);
    189       fail("TestKeyException expected");
    190     } catch (TestKeyException expected) {}
    191     try {
    192       constrained.putAll(ImmutableMap.of("baz", 3, TEST_KEY, 4));
    193       fail("TestKeyException expected");
    194     } catch (TestKeyException expected) {}
    195     try {
    196       constrained.forcePut(TEST_KEY, 3);
    197       fail("TestKeyException expected");
    198     } catch (TestKeyException expected) {}
    199     try {
    200       constrained.inverse().forcePut(TEST_VALUE, "baz");
    201       fail("TestValueException expected");
    202     } catch (TestValueException expected) {}
    203     try {
    204       constrained.inverse().forcePut(3, TEST_KEY);
    205       fail("TestKeyException expected");
    206     } catch (TestKeyException expected) {}
    207     assertEquals(Collections.emptySet(), map.entrySet());
    208     assertEquals(Collections.emptySet(), constrained.entrySet());
    209   }
    210 
    211   public void testConstrainedMultimapLegal() {
    212     Multimap<String, Integer> multimap = LinkedListMultimap.create();
    213     Multimap<String, Integer> constrained = MapConstraints.constrainedMultimap(
    214         multimap, TEST_CONSTRAINT);
    215     multimap.put(TEST_KEY, TEST_VALUE);
    216     constrained.put("foo", 1);
    217     multimap.get("bar").add(2);
    218     constrained.get("baz").add(3);
    219     multimap.get("qux").addAll(Arrays.asList(4));
    220     constrained.get("zig").addAll(Arrays.asList(5));
    221     multimap.putAll("zag", Arrays.asList(6));
    222     constrained.putAll("bee", Arrays.asList(7));
    223     multimap.putAll(new ImmutableMultimap.Builder<String, Integer>()
    224         .put("bim", 8).build());
    225     constrained.putAll(new ImmutableMultimap.Builder<String, Integer>()
    226         .put("bop", 9).build());
    227     multimap.putAll(new ImmutableMultimap.Builder<String, Integer>()
    228         .put("dig", 10).build());
    229     constrained.putAll(new ImmutableMultimap.Builder<String, Integer>()
    230         .put("dag", 11).build());
    231     assertTrue(multimap.equals(constrained));
    232     assertTrue(constrained.equals(multimap));
    233     ASSERT.that(ImmutableList.copyOf(multimap.entries()))
    234         .is(ImmutableList.copyOf(constrained.entries()));
    235     ASSERT.that(constrained.asMap().get("foo")).hasContentsInOrder(1);
    236     assertNull(constrained.asMap().get("missing"));
    237     assertEquals(multimap.asMap(), constrained.asMap());
    238     assertEquals(multimap.values(), constrained.values());
    239     assertEquals(multimap.keys(), constrained.keys());
    240     assertEquals(multimap.keySet(), constrained.keySet());
    241     assertEquals(multimap.toString(), constrained.toString());
    242     assertEquals(multimap.hashCode(), constrained.hashCode());
    243     ASSERT.that(multimap.entries()).hasContentsInOrder(
    244         Maps.immutableEntry(TEST_KEY, TEST_VALUE),
    245         Maps.immutableEntry("foo", 1),
    246         Maps.immutableEntry("bar", 2),
    247         Maps.immutableEntry("baz", 3),
    248         Maps.immutableEntry("qux", 4),
    249         Maps.immutableEntry("zig", 5),
    250         Maps.immutableEntry("zag", 6),
    251         Maps.immutableEntry("bee", 7),
    252         Maps.immutableEntry("bim", 8),
    253         Maps.immutableEntry("bop", 9),
    254         Maps.immutableEntry("dig", 10),
    255         Maps.immutableEntry("dag", 11));
    256     assertFalse(constrained.asMap().values() instanceof Serializable);
    257     Iterator<Collection<Integer>> iterator =
    258         constrained.asMap().values().iterator();
    259     iterator.next();
    260     iterator.next().add(12);
    261     assertTrue(multimap.containsEntry("foo", 12));
    262   }
    263 
    264   public void testConstrainedTypePreservingList() {
    265     ListMultimap<String, Integer> multimap
    266         = MapConstraints.constrainedListMultimap(
    267             LinkedListMultimap.<String, Integer>create(),
    268             TEST_CONSTRAINT);
    269     multimap.put("foo", 1);
    270     Map.Entry<String, Collection<Integer>> entry
    271         = multimap.asMap().entrySet().iterator().next();
    272     assertTrue(entry.getValue() instanceof List);
    273     assertFalse(multimap.entries() instanceof Set);
    274     assertFalse(multimap.get("foo") instanceof RandomAccess);
    275   }
    276 
    277   public void testConstrainedTypePreservingRandomAccessList() {
    278     ListMultimap<String, Integer> multimap
    279         = MapConstraints.constrainedListMultimap(
    280             ArrayListMultimap.<String, Integer>create(),
    281             TEST_CONSTRAINT);
    282     multimap.put("foo", 1);
    283     Map.Entry<String, Collection<Integer>> entry
    284         = multimap.asMap().entrySet().iterator().next();
    285     assertTrue(entry.getValue() instanceof List);
    286     assertFalse(multimap.entries() instanceof Set);
    287     assertTrue(multimap.get("foo") instanceof RandomAccess);
    288   }
    289 
    290   public void testConstrainedTypePreservingSet() {
    291     SetMultimap<String, Integer> multimap
    292         = MapConstraints.constrainedSetMultimap(
    293             LinkedHashMultimap.<String, Integer>create(),
    294             TEST_CONSTRAINT);
    295     multimap.put("foo", 1);
    296     Map.Entry<String, Collection<Integer>> entry
    297         = multimap.asMap().entrySet().iterator().next();
    298     assertTrue(entry.getValue() instanceof Set);
    299   }
    300 
    301   public void testConstrainedTypePreservingSortedSet() {
    302     Comparator<Integer> comparator = Collections.reverseOrder();
    303     SortedSetMultimap<String, Integer> delegate
    304         = TreeMultimap.create(Ordering.<String>natural(), comparator);
    305     SortedSetMultimap<String, Integer> multimap
    306         = MapConstraints.constrainedSortedSetMultimap(delegate,
    307             TEST_CONSTRAINT);
    308     multimap.put("foo", 1);
    309     Map.Entry<String, Collection<Integer>> entry
    310         = multimap.asMap().entrySet().iterator().next();
    311     assertTrue(entry.getValue() instanceof SortedSet);
    312     assertSame(comparator, multimap.valueComparator());
    313     assertSame(comparator, multimap.get("foo").comparator());
    314   }
    315 
    316   @SuppressWarnings("unchecked")
    317   public void testConstrainedMultimapIllegal() {
    318     Multimap<String, Integer> multimap = LinkedListMultimap.create();
    319     Multimap<String, Integer> constrained = MapConstraints.constrainedMultimap(
    320         multimap, TEST_CONSTRAINT);
    321     try {
    322       constrained.put(TEST_KEY, 1);
    323       fail("TestKeyException expected");
    324     } catch (TestKeyException expected) {}
    325     try {
    326       constrained.put("foo", TEST_VALUE);
    327       fail("TestValueException expected");
    328     } catch (TestValueException expected) {}
    329     try {
    330       constrained.put(TEST_KEY, TEST_VALUE);
    331       fail("TestKeyException expected");
    332     } catch (TestKeyException expected) {}
    333     try {
    334       constrained.get(TEST_KEY).add(1);
    335       fail("TestKeyException expected");
    336     } catch (TestKeyException expected) {}
    337     try {
    338       constrained.get("foo").add(TEST_VALUE);
    339       fail("TestValueException expected");
    340     } catch (TestValueException expected) {}
    341     try {
    342       constrained.get(TEST_KEY).add(TEST_VALUE);
    343       fail("TestKeyException expected");
    344     } catch (TestKeyException expected) {}
    345     try {
    346       constrained.get(TEST_KEY).addAll(Arrays.asList(1));
    347       fail("TestKeyException expected");
    348     } catch (TestKeyException expected) {}
    349     try {
    350       constrained.get("foo").addAll(Arrays.asList(1, TEST_VALUE));
    351       fail("TestValueException expected");
    352     } catch (TestValueException expected) {}
    353     try {
    354       constrained.get(TEST_KEY).addAll(Arrays.asList(1, TEST_VALUE));
    355       fail("TestKeyException expected");
    356     } catch (TestKeyException expected) {}
    357     try {
    358       constrained.putAll(TEST_KEY, Arrays.asList(1));
    359       fail("TestKeyException expected");
    360     } catch (TestKeyException expected) {}
    361     try {
    362       constrained.putAll("foo", Arrays.asList(1, TEST_VALUE));
    363       fail("TestValueException expected");
    364     } catch (TestValueException expected) {}
    365     try {
    366       constrained.putAll(TEST_KEY, Arrays.asList(1, TEST_VALUE));
    367       fail("TestKeyException expected");
    368     } catch (TestKeyException expected) {}
    369     try {
    370       constrained.putAll(new ImmutableMultimap.Builder<String, Integer>()
    371           .put(TEST_KEY, 2).put("foo", 1).build());
    372       fail("TestKeyException expected");
    373     } catch (TestKeyException expected) {}
    374     try {
    375       constrained.putAll(new ImmutableMultimap.Builder<String, Integer>()
    376           .put("bar", TEST_VALUE).put("foo", 1).build());
    377       fail("TestValueException expected");
    378     } catch (TestValueException expected) {}
    379     try {
    380       constrained.putAll(new ImmutableMultimap.Builder<String, Integer>()
    381           .put(TEST_KEY, TEST_VALUE).put("foo", 1).build());
    382       fail("TestKeyException expected");
    383     } catch (TestKeyException expected) {}
    384     try {
    385       constrained.entries().add(Maps.immutableEntry(TEST_KEY, 1));
    386       fail("UnsupportedOperationException expected");
    387     } catch (UnsupportedOperationException expected) {}
    388     try {
    389       constrained.entries().addAll(Arrays.asList(
    390           Maps.immutableEntry("foo", 1),
    391           Maps.immutableEntry(TEST_KEY, 2)));
    392       fail("UnsupportedOperationException expected");
    393     } catch (UnsupportedOperationException expected) {}
    394     assertTrue(multimap.isEmpty());
    395     assertTrue(constrained.isEmpty());
    396     constrained.put("foo", 1);
    397     try {
    398       constrained.asMap().get("foo").add(TEST_VALUE);
    399       fail("TestValueException expected");
    400     } catch (TestValueException expected) {}
    401     try {
    402       constrained.asMap().values().iterator().next().add(TEST_VALUE);
    403       fail("TestValueException expected");
    404     } catch (TestValueException expected) {}
    405     try {
    406       ((Collection<Integer>) constrained.asMap().values().toArray()[0])
    407           .add(TEST_VALUE);
    408       fail("TestValueException expected");
    409     } catch (TestValueException expected) {}
    410     ASSERT.that(ImmutableList.copyOf(multimap.entries()))
    411         .is(ImmutableList.copyOf(constrained.entries()));
    412     assertEquals(multimap.asMap(), constrained.asMap());
    413     assertEquals(multimap.values(), constrained.values());
    414     assertEquals(multimap.keys(), constrained.keys());
    415     assertEquals(multimap.keySet(), constrained.keySet());
    416     assertEquals(multimap.toString(), constrained.toString());
    417     assertEquals(multimap.hashCode(), constrained.hashCode());
    418   }
    419 
    420   private static class QueueSupplier implements Supplier<Queue<Integer>> {
    421     @Override
    422     public Queue<Integer> get() {
    423       return new LinkedList<Integer>();
    424     }
    425   }
    426 
    427   public void testConstrainedMultimapQueue() {
    428     Multimap<String, Integer> multimap = Multimaps.newMultimap(
    429         new HashMap<String, Collection<Integer>>(), new QueueSupplier());
    430     Multimap<String, Integer> constrained = MapConstraints.constrainedMultimap(
    431         multimap, TEST_CONSTRAINT);
    432     constrained.put("foo", 1);
    433     assertTrue(constrained.get("foo").contains(1));
    434     assertTrue(multimap.get("foo").contains(1));
    435     try {
    436       constrained.put(TEST_KEY, 1);
    437       fail("TestKeyException expected");
    438     } catch (TestKeyException expected) {}
    439     try {
    440       constrained.put("foo", TEST_VALUE);
    441       fail("TestValueException expected");
    442     } catch (TestValueException expected) {}
    443     try {
    444       constrained.get("foo").add(TEST_VALUE);
    445       fail("TestKeyException expected");
    446     } catch (TestValueException expected) {}
    447     try {
    448       constrained.get(TEST_KEY).add(1);
    449       fail("TestValueException expected");
    450     } catch (TestKeyException expected) {}
    451     assertEquals(1, constrained.size());
    452     assertEquals(1, multimap.size());
    453   }
    454 
    455   public void testMapEntrySetToArray() {
    456     Map<String, Integer> map = Maps.newLinkedHashMap();
    457     Map<String, Integer> constrained
    458         = MapConstraints.constrainedMap(map, TEST_CONSTRAINT);
    459     map.put("foo", 1);
    460     @SuppressWarnings("unchecked")
    461     Map.Entry<String, Integer> entry
    462         = (Map.Entry) constrained.entrySet().toArray()[0];
    463     try {
    464       entry.setValue(TEST_VALUE);
    465       fail("TestValueException expected");
    466     } catch (TestValueException expected) {}
    467     assertFalse(map.containsValue(TEST_VALUE));
    468   }
    469 
    470   public void testMapEntrySetContainsNefariousEntry() {
    471     Map<String, Integer> map = Maps.newTreeMap();
    472     Map<String, Integer> constrained
    473         = MapConstraints.constrainedMap(map, TEST_CONSTRAINT);
    474     map.put("foo", 1);
    475     Map.Entry<String, Integer> nefariousEntry
    476         = nefariousMapEntry(TEST_KEY, TEST_VALUE);
    477     Set<Map.Entry<String, Integer>> entries = constrained.entrySet();
    478     assertFalse(entries.contains(nefariousEntry));
    479     assertFalse(map.containsValue(TEST_VALUE));
    480     assertFalse(entries.containsAll(Collections.singleton(nefariousEntry)));
    481     assertFalse(map.containsValue(TEST_VALUE));
    482   }
    483 
    484   public void testMultimapAsMapEntriesToArray() {
    485     Multimap<String, Integer> multimap = LinkedListMultimap.create();
    486     Multimap<String, Integer> constrained
    487         = MapConstraints.constrainedMultimap(multimap, TEST_CONSTRAINT);
    488     multimap.put("foo", 1);
    489     @SuppressWarnings("unchecked")
    490     Map.Entry<String, Collection<Integer>> entry
    491         = (Map.Entry<String, Collection<Integer>>)
    492             constrained.asMap().entrySet().toArray()[0];
    493     try {
    494       entry.setValue(Collections.<Integer>emptySet());
    495       fail("UnsupportedOperationException expected");
    496     } catch (UnsupportedOperationException expected) {}
    497     try {
    498       entry.getValue().add(TEST_VALUE);
    499       fail("TestValueException expected");
    500     } catch (TestValueException expected) {}
    501     assertFalse(multimap.containsValue(TEST_VALUE));
    502   }
    503 
    504   public void testMultimapAsMapValuesToArray() {
    505     Multimap<String, Integer> multimap = LinkedListMultimap.create();
    506     Multimap<String, Integer> constrained
    507         = MapConstraints.constrainedMultimap(multimap, TEST_CONSTRAINT);
    508     multimap.put("foo", 1);
    509     @SuppressWarnings("unchecked")
    510     Collection<Integer> collection
    511         = (Collection<Integer>) constrained.asMap().values().toArray()[0];
    512     try {
    513       collection.add(TEST_VALUE);
    514       fail("TestValueException expected");
    515     } catch (TestValueException expected) {}
    516     assertFalse(multimap.containsValue(TEST_VALUE));
    517   }
    518 
    519   public void testMultimapEntriesContainsNefariousEntry() {
    520     Multimap<String, Integer> multimap = LinkedListMultimap.create();
    521     Multimap<String, Integer> constrained
    522         = MapConstraints.constrainedMultimap(multimap, TEST_CONSTRAINT);
    523     multimap.put("foo", 1);
    524     Map.Entry<String, Integer> nefariousEntry
    525         = nefariousMapEntry(TEST_KEY, TEST_VALUE);
    526     Collection<Map.Entry<String, Integer>> entries = constrained.entries();
    527     assertFalse(entries.contains(nefariousEntry));
    528     assertFalse(multimap.containsValue(TEST_VALUE));
    529     assertFalse(entries.containsAll(Collections.singleton(nefariousEntry)));
    530     assertFalse(multimap.containsValue(TEST_VALUE));
    531   }
    532 
    533   public void testMultimapEntriesRemoveNefariousEntry() {
    534     Multimap<String, Integer> multimap = LinkedListMultimap.create();
    535     Multimap<String, Integer> constrained
    536         = MapConstraints.constrainedMultimap(multimap, TEST_CONSTRAINT);
    537     multimap.put("foo", 1);
    538     Map.Entry<String, Integer> nefariousEntry
    539         = nefariousMapEntry(TEST_KEY, TEST_VALUE);
    540     Collection<Map.Entry<String, Integer>> entries = constrained.entries();
    541     assertFalse(entries.remove(nefariousEntry));
    542     assertFalse(multimap.containsValue(TEST_VALUE));
    543     assertFalse(entries.removeAll(Collections.singleton(nefariousEntry)));
    544     assertFalse(multimap.containsValue(TEST_VALUE));
    545   }
    546 
    547   public void testMultimapAsMapEntriesContainsNefariousEntry() {
    548     Multimap<String, Integer> multimap = LinkedListMultimap.create();
    549     Multimap<String, Integer> constrained
    550         = MapConstraints.constrainedMultimap(multimap, TEST_CONSTRAINT);
    551     multimap.put("foo", 1);
    552     Map.Entry<String, ? extends Collection<Integer>> nefariousEntry
    553         = nefariousMapEntry(TEST_KEY, Collections.singleton(TEST_VALUE));
    554     Set<Map.Entry<String, Collection<Integer>>> entries
    555         = constrained.asMap().entrySet();
    556     assertFalse(entries.contains(nefariousEntry));
    557     assertFalse(multimap.containsValue(TEST_VALUE));
    558     assertFalse(entries.containsAll(Collections.singleton(nefariousEntry)));
    559     assertFalse(multimap.containsValue(TEST_VALUE));
    560   }
    561 
    562   public void testMultimapAsMapEntriesRemoveNefariousEntry() {
    563     Multimap<String, Integer> multimap = LinkedListMultimap.create();
    564     Multimap<String, Integer> constrained
    565         = MapConstraints.constrainedMultimap(multimap, TEST_CONSTRAINT);
    566     multimap.put("foo", 1);
    567     Map.Entry<String, ? extends Collection<Integer>> nefariousEntry
    568         = nefariousMapEntry(TEST_KEY, Collections.singleton(TEST_VALUE));
    569     Set<Map.Entry<String, Collection<Integer>>> entries
    570         = constrained.asMap().entrySet();
    571     assertFalse(entries.remove(nefariousEntry));
    572     assertFalse(multimap.containsValue(TEST_VALUE));
    573     assertFalse(entries.removeAll(Collections.singleton(nefariousEntry)));
    574     assertFalse(multimap.containsValue(TEST_VALUE));
    575   }
    576 
    577   public void testNefariousMapPutAll() {
    578     Map<String, Integer> map = Maps.newLinkedHashMap();
    579     Map<String, Integer> constrained = MapConstraints.constrainedMap(
    580         map, TEST_CONSTRAINT);
    581     Map<String, Integer> onceIterable = onceIterableMap("foo", 1);
    582     constrained.putAll(onceIterable);
    583     assertEquals((Integer) 1, constrained.get("foo"));
    584   }
    585 
    586   public void testNefariousMultimapPutAllIterable() {
    587     Multimap<String, Integer> multimap = LinkedListMultimap.create();
    588     Multimap<String, Integer> constrained = MapConstraints.constrainedMultimap(
    589         multimap, TEST_CONSTRAINT);
    590     Collection<Integer> onceIterable
    591         = ConstraintsTest.onceIterableCollection(1);
    592     constrained.putAll("foo", onceIterable);
    593     assertEquals(ImmutableList.of(1), constrained.get("foo"));
    594   }
    595 
    596   public void testNefariousMultimapPutAllMultimap() {
    597     Multimap<String, Integer> multimap = LinkedListMultimap.create();
    598     Multimap<String, Integer> constrained = MapConstraints.constrainedMultimap(
    599         multimap, TEST_CONSTRAINT);
    600     Multimap<String, Integer> onceIterable
    601         = Multimaps.forMap(onceIterableMap("foo", 1));
    602     constrained.putAll(onceIterable);
    603     assertEquals(ImmutableList.of(1), constrained.get("foo"));
    604   }
    605 
    606   public void testNefariousMultimapGetAddAll() {
    607     Multimap<String, Integer> multimap = LinkedListMultimap.create();
    608     Multimap<String, Integer> constrained = MapConstraints.constrainedMultimap(
    609         multimap, TEST_CONSTRAINT);
    610     Collection<Integer> onceIterable
    611         = ConstraintsTest.onceIterableCollection(1);
    612     constrained.get("foo").addAll(onceIterable);
    613     assertEquals(ImmutableList.of(1), constrained.get("foo"));
    614   }
    615 
    616   /**
    617    * Returns a "nefarious" map, which permits only one call to its views'
    618    * iterator() methods. This verifies that the constrained map uses a
    619    * defensive copy instead of potentially checking the elements in one snapshot
    620    * and adding the elements from another.
    621    *
    622    * @param key the key to be contained in the map
    623    * @param value the value to be contained in the map
    624    */
    625   static <K, V> Map<K, V> onceIterableMap(K key, V value) {
    626     final Map.Entry<K, V> entry = Maps.immutableEntry(key, value);
    627     return new AbstractMap<K, V>() {
    628       boolean iteratorCalled;
    629       @Override public int size() {
    630         /*
    631          * We could make the map empty, but that seems more likely to trigger
    632          * special cases (so maybe we should test both empty and nonempty...).
    633          */
    634         return 1;
    635       }
    636       @Override public Set<Entry<K, V>> entrySet() {
    637         return new ForwardingSet<Entry<K, V>>() {
    638           @Override protected Set<Entry<K, V>> delegate() {
    639             return Collections.singleton(entry);
    640           }
    641           @Override public Iterator<Entry<K, V>> iterator() {
    642             assertFalse("Expected only one call to iterator()", iteratorCalled);
    643             iteratorCalled = true;
    644             return super.iterator();
    645           }
    646         };
    647       }
    648       @Override public Set<K> keySet() {
    649         throw new UnsupportedOperationException();
    650       }
    651       @Override public Collection<V> values() {
    652         throw new UnsupportedOperationException();
    653       }
    654     };
    655   }
    656 
    657   @GwtIncompatible("SerializableTester")
    658   public void testSerialization() {
    659     // TODO: Test serialization of constrained collections.
    660     assertSame(MapConstraints.notNull(),
    661         SerializableTester.reserialize(MapConstraints.notNull()));
    662   }
    663 }
    664