.isEqualTo("fooBar");
  }

  public void testConverter_nullConversions() {
    for (CaseFormat outer : CaseFormat.values()) {
      for (CaseFormat inner : CaseFormat.values()) {
        assertThat(outer.converterTo(inner).convert(null)).isNull();
        assertThat(outer.converterTo(inner).reverse().convert(null)).isNull();
      }
    }
  }

  public void testConverter_toString() {

public class SynchronizedDequeTest extends TestCase {

  protected Deque<String> create() {
    TestDeque<String> inner = new TestDeque<>();
    Deque<String> outer = Synchronized.deque(inner, inner.mutex);
    outer.add("foo"); // necessary because we try to remove elements later on
    return outer;
  }

  private static final class TestDeque<E> implements Deque<E> {
    private final Deque<E> delegate = new LinkedList<>();

public class SynchronizedDequeTest extends TestCase {

  protected Deque<String> create() {
    TestDeque<String> inner = new TestDeque<>();
    Deque<String> outer = Synchronized.deque(inner, inner.mutex);
    outer.add("foo"); // necessary because we try to remove elements later on
    return outer;
  }

  private static final class TestDeque<E> implements Deque<E> {
    private final Deque<E> delegate = new LinkedList<>();

FIELD java.util.AbstractMap.values com.google.common.collect.TreeRangeMap.SubRangeMap.SubRangeMapAsMap.values.$
OUTER com.google.common.collect.StandardTable.Row

        ClassPath.getClassPathEntry(new File("/home/build/outer.jar"), "file:/usr/test/dep.jar")
            .toURI());
    assertEquals(
        new File("/home/build/a.jar").toURI(),
        ClassPath.getClassPathEntry(new File("/home/build/outer.jar"), "a.jar").toURI());
    assertEquals(
        new File("/home/build/x/y/z").toURI(),
        ClassPath.getClassPathEntry(new File("/home/build/outer.jar"), "x/y/z").toURI());
    assertEquals(

  public final Object mutex = new Object[0]; // something Serializable

  protected <K, V> Map<K, V> create() {
    TestMap<K, V> inner = new TestMap<>(new HashMap<K, V>(), mutex);
    Map<K, V> outer = Synchronized.map(inner, mutex);
    return outer;
  }

  static class TestMap<K, V> extends ForwardingMap<K, V> implements Serializable {
    public final Object mutex;
    private final Map<K, V> delegate;

        String url = "http://example.com/test";
        String message = "Outer error message";
        Exception innerCause = new IllegalArgumentException("Inner cause");
        Exception middleCause = new IllegalStateException("Middle cause", innerCause);
        Exception outerCause = new RuntimeException("Outer cause", middleCause);

            return super.writeReplace();
          }
        };
    ImmutableRangeMap<K, V> outer = this;
    return new ImmutableRangeMap<K, V>(subRanges, values.subList(lowerIndex, upperIndex)) {
      @Override
      public ImmutableRangeMap<K, V> subRangeMap(Range<K> subRange) {
        if (range.isConnected(subRange)) {
          return outer.subRangeMap(subRange.intersection(range));
        } else {

    private static final Logger logger = LogManager.getLogger(RelatedQueryHelper.class);

    /**
     * Map storing related queries organized by virtual host key and search term.
     * The outer map key is the virtual host key, the inner map key is the search term
     * (in lowercase), and the value is an array of related query strings.
     */

    }

    public void test_stackTraceWithCause() {
        // Test that stack trace is properly preserved with cause
        String innerMessage = "Inner exception";
        String outerMessage = "Outer exception";
        RuntimeException innerException = new RuntimeException(innerMessage);
        StorageException exception = new StorageException(outerMessage, innerException);

        assertNotNull(exception.getStackTrace());