Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2008 Google Inc.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.mapdb;
 
Tests representing the contract of java.util.concurrent.ConcurrentMap. Concrete subclasses of this base class test conformance of concrete java.util.concurrent.ConcurrentMap subclasses to that contract.

The tests in this class for null keys and values only check maps for which null keys and values are not allowed. There are currently no java.util.concurrent.ConcurrentMap implementations that support nulls.

Author(s):
Jared Levy
 
 public abstract class ConcurrentMapInterfaceTest<K, V>
     extends MapInterfaceTest<K, V> {
 
   protected ConcurrentMapInterfaceTest(boolean allowsNullKeys,
       boolean allowsNullValuesboolean supportsPutboolean supportsRemove,
       boolean supportsClearboolean supportsIteratorRemoveboolean supportsEntrySetValue) {
     super(allowsNullKeysallowsNullValuessupportsPutsupportsRemove,
         supportsClear,supportsIteratorRemovesupportsEntrySetValue);
   }

  
Creates a new value that is not expected to be found in makePopulatedMap() and differs from the value returned by getValueNotInPopulatedMap().

Returns:
a value
Throws:
java.lang.UnsupportedOperationException if it's not possible to make a value that will not be found in the map
 
   protected abstract V getSecondValueNotInPopulatedMap()
       throws UnsupportedOperationException;
 
   @Override protected abstract ConcurrentMap<K, V> makeEmptyMap()
       throws UnsupportedOperationException;
 
   @Override protected abstract ConcurrentMap<K, V> makePopulatedMap()
       throws UnsupportedOperationException;
 
   @Override protected ConcurrentMap<K, V> makeEitherMap() {
     try {
       return makePopulatedMap();
     } catch (UnsupportedOperationException e) {
       return makeEmptyMap();
     }
   }
 
   public void testPutIfAbsentNewKey() {
     final ConcurrentMap<K, V> map;
     final K keyToPut;
     final V valueToPut;
     try {
       map = makeEitherMap();
       keyToPut = getKeyNotInPopulatedMap();
       valueToPut = getValueNotInPopulatedMap();
     } catch (UnsupportedOperationException e) {
       return;
     }
     if (supportsPut) {
       int initialSize = map.size();
       V oldValue = map.putIfAbsent(keyToPutvalueToPut);
       assertEquals(valueToPutmap.get(keyToPut));
       assertTrue(map.containsKey(keyToPut));
       assertTrue(map.containsValue(valueToPut));
 
       assertEquals(initialSize + 1, map.size());
       assertNull(oldValue);
     } else {
       try {
         map.putIfAbsent(keyToPutvalueToPut);
         fail("Expected UnsupportedOperationException.");
       } catch (UnsupportedOperationException e) {
         // Expected.
       }
     }
     assertInvariants(map);
   }
 
   public void testPutIfAbsentExistingKey() {
    final ConcurrentMap<K, V> map;
    final K keyToPut;
    final V valueToPut;
    try {
      map = makePopulatedMap();
      valueToPut = getValueNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    keyToPut = map.keySet().iterator().next();
    if (supportsPut) {
      V oldValue = map.get(keyToPut);
      int initialSize = map.size();
      assertEquals(oldValuemap.putIfAbsent(keyToPutvalueToPut));
      assertEquals(oldValuemap.get(keyToPut));
      assertTrue(map.containsKey(keyToPut));
      assertTrue(map.containsValue(oldValue));
      assertFalse(map.containsValue(valueToPut));
      assertEquals(initialSizemap.size());
    } else {
      try {
        map.putIfAbsent(keyToPutvalueToPut);
        fail("Expected UnsupportedOperationException.");
      } catch (UnsupportedOperationException e) {
        // Expected.
      }
    }
    assertInvariants(map);
  }
  public void testPutIfAbsentNullKey() {
    if (allowsNullKeys) {
      return;   // Not yet implemented
    }
    final ConcurrentMap<K, V> map;
    final V valueToPut;
    try {
      map = makeEitherMap();
      valueToPut = getValueNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    int initialSize = map.size();
    if (supportsPut) {
      try {
        map.putIfAbsent(nullvalueToPut);
        fail("Expected NullPointerException");
      } catch (NullPointerException e) {
        // Expected.
      }
    } else {
      try {
        map.putIfAbsent(nullvalueToPut);
        fail("Expected UnsupportedOperationException or NullPointerException");
      } catch (UnsupportedOperationException e) {
        // Expected.
      } catch (NullPointerException e) {
        // Expected.
      }
    }
    assertEquals(initialSizemap.size());
    assertInvariants(map);
  }
  public void testPutIfAbsentNewKeyNullValue() {
    if (allowsNullValues) {
      return;   // Not yet implemented
    }
    final ConcurrentMap<K, V> map;
    final K keyToPut;
    try {
      map = makeEitherMap();
      keyToPut = getKeyNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    int initialSize = map.size();
    if (supportsPut) {
      try {
        map.putIfAbsent(keyToPutnull);
        fail("Expected NullPointerException");
      } catch (NullPointerException e) {
        // Expected.
      }
    } else {
      try {
        map.putIfAbsent(keyToPutnull);
        fail("Expected UnsupportedOperationException or NullPointerException");
      } catch (UnsupportedOperationException e) {
        // Expected.
      } catch (NullPointerException e) {
        // Expected.
      }
    }
    assertEquals(initialSizemap.size());
    assertInvariants(map);
  }
  public void testRemoveKeyValueExisting() {
    final ConcurrentMap<K, V> map;
    final K keyToRemove;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    keyToRemove = map.keySet().iterator().next();
    V oldValue = map.get(keyToRemove);
    if (supportsRemove) {
      int initialSize = map.size();
      assertTrue(map.remove(keyToRemoveoldValue));
      assertFalse(map.containsKey(keyToRemove));
      assertEquals(initialSize - 1, map.size());
    } else {
      try {
        map.remove(keyToRemoveoldValue);
        fail("Expected UnsupportedOperationException.");
      } catch (UnsupportedOperationException e) {
        // Expected.
      }
    }
    assertInvariants(map);
  }
  public void testRemoveKeyValueMissingKey() {
    final ConcurrentMap<K, V> map;
    final K keyToRemove;
    final V valueToRemove;
    try {
      map = makePopulatedMap();
      keyToRemove = getKeyNotInPopulatedMap();
      valueToRemove = getValueNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    if (supportsRemove) {
      int initialSize = map.size();
      assertFalse(map.remove(keyToRemovevalueToRemove));
      assertEquals(initialSizemap.size());
    } else {
      try {
        map.remove(keyToRemovevalueToRemove);
        fail("Expected UnsupportedOperationException.");
      } catch (UnsupportedOperationException e) {
        // Expected.
      }
    }
    assertInvariants(map);
  }
    final ConcurrentMap<K, V> map;
    final K keyToRemove;
    final V valueToRemove;
    try {
      map = makePopulatedMap();
      valueToRemove = getValueNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    keyToRemove = map.keySet().iterator().next();
    if (supportsRemove) {
      int initialSize = map.size();
      V oldValue = map.get(keyToRemove);
      assertFalse(map.remove(keyToRemovevalueToRemove));
      assertEquals(oldValuemap.get(keyToRemove));
      assertTrue(map.containsKey(keyToRemove));
      assertEquals(initialSizemap.size());
    } else {
      try {
        map.remove(keyToRemovevalueToRemove);
        fail("Expected UnsupportedOperationException.");
      } catch (UnsupportedOperationException e) {
        // Expected.
      }
    }
    assertInvariants(map);
  }
  public void testRemoveKeyValueNullKey() {
    if (allowsNullKeys) {
      return;   // Not yet implemented
    }
    final ConcurrentMap<K, V> map;
    final V valueToRemove;
    try {
      map = makeEitherMap();
      valueToRemove = getValueNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    int initialSize = map.size();
    if (supportsRemove) {
      try {
        assertFalse(map.remove(nullvalueToRemove));
      } catch (NullPointerException e) {
        // Optional.
      }
    } else {
      try {
        assertFalse(map.remove(nullvalueToRemove));
      } catch (UnsupportedOperationException e) {
        // Optional.
      } catch (NullPointerException e) {
        // Optional.
      }
    }
    assertEquals(initialSizemap.size());
    assertInvariants(map);
  }
    if (allowsNullValues) {
      return;   // Not yet implemented
    }
    final ConcurrentMap<K, V> map;
    final K keyToRemove;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    keyToRemove = map.keySet().iterator().next();
    int initialSize = map.size();
    if (supportsRemove) {
      try {
        assertFalse(map.remove(keyToRemovenull));
      } catch (NullPointerException e) {
        // Optional.
      }
    } else {
      try {
        assertFalse(map.remove(keyToRemovenull));
      } catch (UnsupportedOperationException e) {
        // Optional.
      } catch (NullPointerException e) {
        // Optional.
      }
    }
    assertEquals(initialSizemap.size());
    assertInvariants(map);
  }
    if (allowsNullValues) {
      return;   // Not yet implemented
    }
    final ConcurrentMap<K, V> map;
    final K keyToRemove;
    try {
      map = makeEitherMap();
      keyToRemove = getKeyNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    int initialSize = map.size();
    if (supportsRemove) {
      try {
        assertFalse(map.remove(keyToRemovenull));
      } catch (NullPointerException e) {
        // Optional.
      }
    } else {
      try {
        assertFalse(map.remove(keyToRemovenull));
      } catch (UnsupportedOperationException e) {
        // Optional.
      } catch (NullPointerException e) {
        // Optional.
      }
    }
    assertEquals(initialSizemap.size());
    assertInvariants(map);
  }
  /* Replace2 tests call 2-parameter replace(key, value) */
  public void testReplace2ExistingKey() {
    final ConcurrentMap<K, V> map;
    final K keyToReplace;
    final V newValue;
    try {
      map = makePopulatedMap();
      newValue = getValueNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    keyToReplace = map.keySet().iterator().next();
    if (supportsPut) {
      V oldValue = map.get(keyToReplace);
      int initialSize = map.size();
      assertEquals(oldValuemap.replace(keyToReplacenewValue));
      assertEquals(newValuemap.get(keyToReplace));
      assertTrue(map.containsKey(keyToReplace));
      assertTrue(map.containsValue(newValue));
      assertEquals(initialSizemap.size());
    } else {
      try {
        map.replace(keyToReplacenewValue);
        fail("Expected UnsupportedOperationException.");
      } catch (UnsupportedOperationException e) {
        // Expected.
      }
    }
    assertInvariants(map);
  }
  public void testReplace2MissingKey() {
    final ConcurrentMap<K, V> map;
    final K keyToReplace;
    final V newValue;
    try {
      map = makeEitherMap();
      keyToReplace = getKeyNotInPopulatedMap();
      newValue = getValueNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    if (supportsPut) {
      int initialSize = map.size();
      assertNull(map.replace(keyToReplacenewValue));
      assertNull(map.get(keyToReplace));
      assertFalse(map.containsKey(keyToReplace));
      assertFalse(map.containsValue(newValue));
      assertEquals(initialSizemap.size());
    } else {
      try {
        map.replace(keyToReplacenewValue);
        fail("Expected UnsupportedOperationException.");
      } catch (UnsupportedOperationException e) {
        // Expected.
      }
    }
    assertInvariants(map);
  }
  public void testReplace2NullKey() {
    if (allowsNullKeys) {
      return;   // Not yet implemented
    }
    final ConcurrentMap<K, V> map;
    final V valueToReplace;
    try {
      map = makeEitherMap();
      valueToReplace = getValueNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    int initialSize = map.size();
    if (supportsPut) {
      try {
        assertNull(map.replace(nullvalueToReplace));
      } catch (NullPointerException e) {
        // Optional.
      }
    } else {
      try {
        assertNull(map.replace(nullvalueToReplace));
      } catch (UnsupportedOperationException e) {
        // Optional.
      } catch (NullPointerException e) {
        // Optional.
      }
    }
    assertEquals(initialSizemap.size());
    assertInvariants(map);
  }
    if (allowsNullValues) {
      return;   // Not yet implemented
    }
    final ConcurrentMap<K, V> map;
    final K keyToReplace;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    keyToReplace = map.keySet().iterator().next();
    int initialSize = map.size();
    if (supportsPut) {
      try {
        map.replace(keyToReplacenull);
        fail("Expected NullPointerException");
      } catch (NullPointerException e) {
        // Expected.
      }
    } else {
      try {
        map.replace(keyToReplacenull);
        fail("Expected UnsupportedOperationException or NullPointerException");
      } catch (UnsupportedOperationException e) {
        // Expected.
      } catch (NullPointerException e) {
        // Expected.
      }
    }
    assertEquals(initialSizemap.size());
    assertInvariants(map);
  }
  public void testReplace2MissingKeyNullValue() {
    if (allowsNullValues) {
      return;   // Not yet implemented
    }
    final ConcurrentMap<K, V> map;
    final K keyToReplace;
    try {
      map = makeEitherMap();
      keyToReplace = getKeyNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    int initialSize = map.size();
    if (supportsPut) {
      try {
        assertNull(map.replace(keyToReplacenull));
      } catch (NullPointerException e) {
        // Optional.
      }
    } else {
      try {
        assertNull(map.replace(keyToReplacenull));
      } catch (UnsupportedOperationException e) {
        // Optional.
      } catch (NullPointerException e) {
        // Optional.
      }
    }
    assertEquals(initialSizemap.size());
    assertInvariants(map);
  }
  /*
   * Replace3 tests call 3-parameter replace(key, oldValue, newValue)
   */
  public void testReplace3ExistingKeyValue() {
    final ConcurrentMap<K, V> map;
    final K keyToReplace;
    final V oldValue;
    final V newValue;
    try {
      map = makePopulatedMap();
      newValue = getValueNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    keyToReplace = map.keySet().iterator().next();
    oldValue = map.get(keyToReplace);
    if (supportsPut) {
      int initialSize = map.size();
      assertTrue(map.replace(keyToReplaceoldValuenewValue));
      assertEquals(newValuemap.get(keyToReplace));
      assertTrue(map.containsKey(keyToReplace));
      assertTrue(map.containsValue(newValue));
      assertFalse(map.containsValue(oldValue));
      assertEquals(initialSizemap.size());
    } else {
      try {
        map.replace(keyToReplaceoldValuenewValue);
        fail("Expected UnsupportedOperationException.");
      } catch (UnsupportedOperationException e) {
        // Expected.
      }
    }
    assertInvariants(map);
  }
    final ConcurrentMap<K, V> map;
    final K keyToReplace;
    final V oldValue;
    final V newValue;
    try {
      map = makePopulatedMap();
      oldValue = getValueNotInPopulatedMap();
      newValue = getSecondValueNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    keyToReplace = map.keySet().iterator().next();
    final V originalValue = map.get(keyToReplace);
    int initialSize = map.size();
    if (supportsPut) {
      assertFalse(map.replace(keyToReplaceoldValuenewValue));
    } else {
      try {
        map.replace(keyToReplaceoldValuenewValue);
        fail("Expected UnsupportedOperationException.");
      } catch (UnsupportedOperationException e) {
        // Expected.
      }
    }
    assertTrue(map.containsKey(keyToReplace));
    assertFalse(map.containsValue(newValue));
    assertFalse(map.containsValue(oldValue));
    assertEquals(originalValuemap.get(keyToReplace));
    assertEquals(initialSizemap.size());
    assertInvariants(map);
  }
  public void testReplace3MissingKey() {
    final ConcurrentMap<K, V> map;
    final K keyToReplace;
    final V oldValue;
    final V newValue;
    try {
      map = makeEitherMap();
      keyToReplace = getKeyNotInPopulatedMap();
      oldValue = getValueNotInPopulatedMap();
      newValue = getSecondValueNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    int initialSize = map.size();
    if (supportsPut) {
      assertFalse(map.replace(keyToReplaceoldValuenewValue));
    } else {
      try {
        map.replace(keyToReplaceoldValuenewValue);
        fail("Expected UnsupportedOperationException.");
      } catch (UnsupportedOperationException e) {
        // Expected.
      }
    }
    assertFalse(map.containsKey(keyToReplace));
    assertFalse(map.containsValue(newValue));
    assertFalse(map.containsValue(oldValue));
    assertEquals(initialSizemap.size());
    assertInvariants(map);
  }
  public void testReplace3NullKey() {
    if (allowsNullKeys) {
      return;   // Not yet implemented
    }
    final ConcurrentMap<K, V> map;
    final V oldValue;
    final V newValue;
    try {
      map = makeEitherMap();
      oldValue = getValueNotInPopulatedMap();
      newValue = getSecondValueNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    int initialSize = map.size();
    if (supportsPut) {
      try {
        assertFalse(map.replace(nulloldValuenewValue));
      } catch (NullPointerException e) {
        // Optional.
      }
    } else {
      try {
        assertFalse(map.replace(nulloldValuenewValue));
      } catch (UnsupportedOperationException e) {
        // Optional.
      } catch (NullPointerException e) {
        // Optional.
      }
    }
    assertEquals(initialSizemap.size());
    assertInvariants(map);
  }
    if (allowsNullValues) {
      return;   // Not yet implemented
    }
    final ConcurrentMap<K, V> map;
    final K keyToReplace;
    final V newValue;
    try {
      map = makePopulatedMap();
      newValue = getValueNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    keyToReplace = map.keySet().iterator().next();
    final V originalValue = map.get(keyToReplace);
    int initialSize = map.size();
    if (supportsPut) {
      try {
        assertFalse(map.replace(keyToReplacenullnewValue));
      } catch (NullPointerException e) {
        // Optional.
      }
    } else {
      try {
        assertFalse(map.replace(keyToReplacenullnewValue));
      } catch (UnsupportedOperationException e) {
        // Optional.
      } catch (NullPointerException e) {
        // Optional.
      }
    }
    assertEquals(initialSizemap.size());
    assertEquals(originalValuemap.get(keyToReplace));
    assertInvariants(map);
  }
    if (allowsNullValues) {
      return;   // Not yet implemented
    }
    final ConcurrentMap<K, V> map;
    final K keyToReplace;
    final V newValue;
    try {
      map = makeEitherMap();
      keyToReplace = getKeyNotInPopulatedMap();
      newValue = getValueNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    int initialSize = map.size();
    if (supportsPut) {
      try {
        assertFalse(map.replace(keyToReplacenullnewValue));
      } catch (NullPointerException e) {
        // Optional.
      }
    } else {
      try {
        assertFalse(map.replace(keyToReplacenullnewValue));
      } catch (UnsupportedOperationException e) {
        // Optional.
      } catch (NullPointerException e) {
        // Optional.
      }
    }
    assertEquals(initialSizemap.size());
    assertInvariants(map);
  }
    if (allowsNullValues) {
      return;   // Not yet implemented
    }
    final ConcurrentMap<K, V> map;
    final K keyToReplace;
    final V oldValue;
    try {
      map = makeEitherMap();
      keyToReplace = getKeyNotInPopulatedMap();
      oldValue = getValueNotInPopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    int initialSize = map.size();
    if (supportsPut) {
      try {
        map.replace(keyToReplaceoldValuenull);
      } catch (NullPointerException e) {
        // Optional.
      }
    } else {
      try {
        map.replace(keyToReplaceoldValuenull);
      } catch (UnsupportedOperationException e) {
        // Optional.
      } catch (NullPointerException e) {
        // Optional.
      }
    }
    assertEquals(initialSizemap.size());
    assertInvariants(map);
  }
    if (allowsNullValues) {
      return;   // Not yet implemented
    }
    final ConcurrentMap<K, V> map;
    final K keyToReplace;
    final V oldValue;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    keyToReplace = map.keySet().iterator().next();
    oldValue = map.get(keyToReplace);
    int initialSize = map.size();
    if (supportsPut) {
      try {
        map.replace(keyToReplaceoldValuenull);
        fail("Expected NullPointerException");
      } catch (NullPointerException e) {
        // Expected.
      }
    } else {
      try {
        map.replace(keyToReplaceoldValuenull);
        fail("Expected UnsupportedOperationException or NullPointerException");
      } catch (UnsupportedOperationException e) {
        // Expected.
      } catch (NullPointerException e) {
        // Expected.
      }
    }
    assertEquals(initialSizemap.size());
    assertEquals(oldValuemap.get(keyToReplace));
    assertInvariants(map);
  }
New to GrepCode? Check out our FAQ X