return getUrl();
    }

    @Override
    public Map<String, Object> toSource() {
        final Map<String, Object> sourceMap = super.toSource();
        if (fields != null) {
            sourceMap.putAll(fields);
        }
        return sourceMap;
    }

    @Override
    protected void addFieldToSource(final Map<String, Object> sourceMap, final String field, final Object value) {

        return getCreatedAt();
    }

    @Override
    public Map<String, Object> toSource() {
        final Map<String, Object> sourceMap = super.toSource();
        if (fields != null) {
            sourceMap.putAll(fields);
        }
        return sourceMap;
    }

    @Override
    protected void addFieldToSource(final Map<String, Object> sourceMap, final String field, final Object value) {

    /**
     * 
     * @param key
     *            cache key
     */
    void setKey ( String key );


    /**
     * @param map
     */
    void setCacheMap ( Map<String, DfsReferralDataInternal> map );


    /**
     * Replaces the entry with key in the cache map with this referral
     */
    void replaceCache ();


    /**
     * Not exactly sure what that is all about, certainly legacy stuff

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.codelibs.fess.unit.UnitFessTestCase;

public class DocumentUtilTest extends UnitFessTestCase {

    public void test_string() {
        Map<String, Object> doc = new HashMap<>();

        String expected = "1";
        doc.put("key1", expected);

    protected volatile Map<String, List<Pattern>> includeUrlPatternMap = new HashMap<>();

    protected volatile Map<String, List<Pattern>> excludeUrlPatternMap = new HashMap<>();

    public void clear() {
        urlQueueMap.clear();
        sessionMap.clear();
    }

    public synchronized Queue<UrlQueueImpl<Long>> getUrlQueueList(final String sessionId) {

    map.put("bar", 1);
    map.put("foo", 2);
    map.put("bar", 3);
    map.put("bar", 4);
    assertEquals("[1, 2, 3, 4]", map.values().toString());
    map.values().remove(2);
    assertEquals("{bar=[1, 3, 4]}", map.toString());
  }

  public void testLinkedEntries() {
    Multimap<String, Integer> map = create();
    map.put("bar", 1);
    map.put("foo", 2);
    map.put("bar", 3);

  }

  public void testCreateFromMap() {
    /* Test with non-empty Map. */
    Map<Currency, String> map =
        ImmutableMap.of(
            Currency.DOLLAR, "dollar",
            Currency.PESO, "peso",
            Currency.FRANC, "franc");
    EnumHashBiMap<Currency, String> bimap = EnumHashBiMap.create(map);
    assertEquals("dollar", bimap.get(Currency.DOLLAR));

    // Hack around K not being a subtype of Comparable.
    // Unsafe, see ImmutableSortedSetFauxverideShim.
    @SuppressWarnings("unchecked")
    Ordering<K> naturalOrder = (Ordering<K>) NATURAL_ORDER;
    return copyOfInternal(map, naturalOrder);
  }

  /**
   * Returns an immutable map containing the same entries as {@code map}, with keys sorted by the

    private final AtomicBoolean setUpRan;

    CheckSetUpInvocationHandler(Map<String, String> map, AtomicBoolean setUpRan) {
      this.map = map;
      this.setUpRan = setUpRan;
    }

    @Override
    public Object invoke(Object target, Method method, Object[] args) throws Throwable {
      assertTrue("setUp should have run", setUpRan.get());
      try {
        return method.invoke(map, args);

    final ConcurrentMap<?, ?> map;

    AbstractCacheSet(ConcurrentMap<?, ?> map) {
      this.map = map;
    }

    @Override
    public int size() {
      return map.size();
    }

    @Override
    public boolean isEmpty() {
      return map.isEmpty();
    }

    @Override
    public void clear() {
      map.clear();
    }
  }