assertFalse(cache.asMap().containsValue(one));

    cache.put(one, two);

    assertSame(two, cache.getIfPresent(one));
    stats = cache.stats();
    assertEquals(2, stats.missCount());
    assertEquals(0, stats.loadSuccessCount());
    assertEquals(0, stats.loadExceptionCount());
    assertEquals(1, stats.hitCount());
    assertSame(two, cache.asMap().get(one));
    assertTrue(cache.asMap().containsKey(one));

          if (prev != null) {
            assertSame(prev, current.getPreviousInWriteQueue());
            assertSame(prev.getNextInWriteQueue(), current);
            assertThat(prev.getWriteTime()).isAtMost(current.getWriteTime());
          }
          Object key = current.getKey();
          if (key != null) {
            assertSame(current, segment.getEntry(key, current.getHash()));
          }

    // more excruciating tests! Hooray!

    assertSame(CharMatcher.any(), CharMatcher.none().negate());
    assertSame(CharMatcher.none(), CharMatcher.any().negate());

    assertSame(WHATEVER, CharMatcher.any().and(WHATEVER));
    assertSame(CharMatcher.any(), CharMatcher.any().or(WHATEVER));

    assertSame(CharMatcher.none(), CharMatcher.none().and(WHATEVER));
    assertSame(WHATEVER, CharMatcher.none().or(WHATEVER));
  }

    // more excruciating tests! Hooray!

    assertSame(CharMatcher.any(), CharMatcher.none().negate());
    assertSame(CharMatcher.none(), CharMatcher.any().negate());

    assertSame(WHATEVER, CharMatcher.any().and(WHATEVER));
    assertSame(CharMatcher.any(), CharMatcher.any().or(WHATEVER));

    assertSame(CharMatcher.none(), CharMatcher.none().and(WHATEVER));
    assertSame(WHATEVER, CharMatcher.none().or(WHATEVER));
  }

     */
    @Test
    public void testDefaultValue() {
        final Hoge hoge = new Hoge();
        assertSame(ObjectUtil.defaultValue(null, hoge), hoge);
        assertSame(ObjectUtil.defaultValue(hoge, null), hoge);
        assertSame(ObjectUtil.defaultValue(hoge, hoge), hoge);
        assertSame(ObjectUtil.defaultValue(null, null), null);
        assertThat(ObjectUtil.defaultValue(null, "NULL"), is("NULL"));

    assertFalse(Strings.isNullOrEmpty("a"));
  }

  public void testPadStart_noPadding() {
    assertSame("", Strings.padStart("", 0, '-'));
    assertSame("x", Strings.padStart("x", 0, '-'));
    assertSame("x", Strings.padStart("x", 1, '-'));
    assertSame("xx", Strings.padStart("xx", 0, '-'));
    assertSame("xx", Strings.padStart("xx", 2, '-'));
  }

  public void testPadStart_somePadding() {

  public void testEmpty_comparator() {
    SortedSet<String> set = of();
    assertSame(Ordering.natural(), set.comparator());
  }

  public void testEmpty_headSet() {
    SortedSet<String> set = of();
    assertSame(set, set.headSet("c"));
  }

  public void testEmpty_tailSet() {
    SortedSet<String> set = of();
    assertSame(set, set.tailSet("f"));
  }

  public void testEmpty_subSet() {

    Converter<String, String> stringIdentityConverter = Converter.identity();

    assertSame(stringIdentityConverter, stringIdentityConverter.reverse());
    assertSame(STR_TO_LONG, stringIdentityConverter.andThen(STR_TO_LONG));

    assertSame(STR_VAL, stringIdentityConverter.convert(STR_VAL));
    assertSame(STR_VAL, stringIdentityConverter.reverse().convert(STR_VAL));

          if (prev != null) {
            assertSame(prev, current.getPreviousInWriteQueue());
            assertSame(prev.getNextInWriteQueue(), current);
            assertThat(prev.getWriteTime()).isAtMost(current.getWriteTime());
          }
          Object key = current.getKey();
          if (key != null) {
            assertSame(current, segment.getEntry(key, current.getHash()));
          }

    assertTrue(descendingSet instanceof SynchronizedNavigableSet);
    assertSame(set, ((SynchronizedNavigableSet<String>) descendingSet).mutex);
  }

  public void testHeadSet_E() {
    NavigableSet<String> set = create();
    SortedSet<String> headSet = set.headSet("a");
    assertTrue(headSet instanceof SynchronizedSortedSet);
    assertSame(set, ((SynchronizedSortedSet<String>) headSet).mutex);
  }