protected TestAbstractCache(String str) 
{
                   
        super(str);
}

Constructor

Parameters:

str - The test name (required by JUnit)

 abstract protected AbstractConcurrentReadCache getCache()

 abstract public  void testContainsKey()
Test the method that verify if the cache contains a specific key

 abstract public  void testGet()
Test the get from the cache

 public  void testGetSetMaxEntries() 
{
        getCache().setMaxEntries(MAX_ENTRIES);
        assertEquals(MAX_ENTRIES, getCache().getMaxEntries());
        // Specify an invalid capacity
        try {
            getCache().setMaxEntries(INVALID_MAX_ENTRIES);
            fail("Cache capacity set with an invalid argument");
        } catch (Exception e) {
            // This is what we expect
        }
}

Test the capacity setting

 public  void testGetSetMemoryCache() 
{
        getCache().setMemoryCaching(true);
        assertTrue(getCache().isMemoryCaching());
}

Test the setting of the memory cache

 public  void testGroups() 
{
    	/* TODO uncomment for 2.3.2 and for fixing issues CACHE-188 and maybe CACHE-244
      String KEY = "testkey";
      String KEY2 = "testkey2";
      String GROUP_NAME = "group1";
      CacheEntry entry = new CacheEntry(KEY, null);
      entry.setContent("testvalue");
      entry.setGroups(new String[] {GROUP_NAME});
      getCache().put(KEY, entry);
      Map m = getCache().getGroupsForReading();
      assertNotNull("group must exist", m.get(GROUP_NAME));
      try {
        Set group = (Set)m.get(GROUP_NAME);
        assertEquals(1, group.size());
        Object keyFromGroup = group.iterator().next();
        assertEquals(KEY, keyFromGroup);
      } catch (ClassCastException e) {
        fail("group should have been a java.util.Set but is a " +
            m.get(GROUP_NAME).getClass().getName());
      }
      assertNotNull(getCache().remove(KEY));
      m = getCache().getGroupsForReading();
      assertNull("group should have been deleted (see CACHE-188)", m.get(GROUP_NAME));
      getCache().clear();
      // Test if persistence options are correctly considered for groups
      try {
        PersistenceListener listener = new MockPersistenceListener();
        getCache().setPersistenceListener(listener);
        getCache().setOverflowPersistence(false);
        getCache().put(KEY, entry);
        assertTrue(listener.isStored(KEY));
        Set group = listener.retrieveGroup(GROUP_NAME);
        assertNotNull(group);
        assertTrue(group.contains(KEY));
        getCache().remove(KEY);
        assertFalse(listener.isStored(KEY));
        getCache().clear();
        // test overflow persistence
        getCache().setOverflowPersistence(true);
        getCache().setMaxEntries(1);
        getCache().put(KEY, entry);
        assertFalse(listener.isStored(KEY));
        // is it correct that the group is persisted, even when we use overflow only?
        // assertFalse(listener.isGroupStored(GROUP_NAME));
        CacheEntry entry2 = new CacheEntry(KEY2);
        entry2.setContent("testvalue");
        entry2.setGroups(new String[] {GROUP_NAME});
        getCache().put(KEY2, entry2);
        // oldest must have been persisted to disk:
        assertTrue(listener.isStored(KEY));
        assertFalse(listener.isStored(KEY2));
        assertNotNull(getCache().get(KEY2));
      } catch (CachePersistenceException e) {
        e.printStackTrace();
        fail("Excpetion was thrown");
      }
      */
}

Test that groups are correctly updated on puts and removes See CACHE-188 and maybe CACHE-244

 abstract public  void testIterator()
Test the iterator retrieval

 abstract public  void testPut()
Test the put into the cache

 abstract public  void testRemove()
Test the remove from the cache

 abstract public  void testRemoveItem()
Test the specific details about the cache algorithm

 public  void testSetPersistenceListener() 
{
        getCache().setPersistenceListener(null);
}

Test the PersistenceListener setter. Since the persistance listener is an interface, just call the setter with null