guava/guava-tests/test/com/google/common/cache/ForwardingLoadingCacheTest.java

/*
 * Copyright (C) 2009 The Guava Authors
 *
 * 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 com.google.common.cache;

import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;

import junit.framework.TestCase;

import java.util.concurrent.ExecutionException;

/**
 * Unit test for {@link ForwardingLoadingCache}.
 *
 * @author Charles Fry
 */
public class ForwardingLoadingCacheTest extends TestCase {
  private LoadingCache<String, Boolean> forward;
  private LoadingCache<String, Boolean> mock;

  @SuppressWarnings("unchecked") // createMock
  @Override public void setUp() throws Exception {
    super.setUp();
    /*
     * Class parameters must be raw, so we can't create a proxy with generic
     * type arguments. The created proxy only records calls and returns null, so
     * the type is irrelevant at runtime.
     */
    mock = createMock(LoadingCache.class);
    forward = new ForwardingLoadingCache<String, Boolean>() {
      @Override protected LoadingCache<String, Boolean> delegate() {
        return mock;
      }
    };
  }

  public void testGet() throws ExecutionException {
    expect(mock.get("key")).andReturn(Boolean.TRUE);
    replay(mock);
    assertSame(Boolean.TRUE, forward.get("key"));
    verify(mock);
  }

  public void testGetUnchecked() {
    expect(mock.getUnchecked("key")).andReturn(Boolean.TRUE);
    replay(mock);
    assertSame(Boolean.TRUE, forward.getUnchecked("key"));
    verify(mock);
  }

  public void testGetAll() throws ExecutionException {
    expect(mock.getAll(ImmutableList.of("key"))).andReturn(ImmutableMap.of("key", Boolean.TRUE));
    replay(mock);
    assertEquals(ImmutableMap.of("key", Boolean.TRUE), forward.getAll(ImmutableList.of("key")));
    verify(mock);
  }

  public void testApply() {
    expect(mock.apply("key")).andReturn(Boolean.TRUE);
    replay(mock);
    assertSame(Boolean.TRUE, forward.apply("key"));
    verify(mock);
  }

  public void testInvalidate() {
    mock.invalidate("key");
    replay(mock);
    forward.invalidate("key");
    verify(mock);
  }

  public void testRefresh() throws ExecutionException {
    mock.refresh("key");
    replay(mock);
    forward.refresh("key");
    verify(mock);
  }

  public void testInvalidateAll() {
    mock.invalidateAll();
    replay(mock);
    forward.invalidateAll();
    verify(mock);
  }

  public void testSize() {
    expect(mock.size()).andReturn(0L);
    replay(mock);
    forward.size();
    verify(mock);
  }

  public void testStats() {
    expect(mock.stats()).andReturn(null);
    replay(mock);
    assertNull(forward.stats());
    verify(mock);
  }

  public void testAsMap() {
    expect(mock.asMap()).andReturn(null);
    replay(mock);
    assertNull(forward.asMap());
    verify(mock);
  }

  public void testCleanUp() {
    mock.cleanUp();
    replay(mock);
    forward.cleanUp();
    verify(mock);
  }

  /**
   * Make sure that all methods are forwarded.
   */
  private static class OnlyGet<K, V> extends ForwardingLoadingCache<K, V> {
    @Override
    protected LoadingCache<K, V> delegate() {
      return null;
    }
  }
}