return false;
                }
                if ("admin".equalsIgnoreCase(v.getValue3()) || "common".equalsIgnoreCase(v.getValue3())
                        || "error".equalsIgnoreCase(v.getValue3()) || "login".equalsIgnoreCase(v.getValue3())
                        || "profile".equalsIgnoreCase(v.getValue3())) {
                    return false;
                }
                return true;

        assertEquals("ja", result[1].getValues()[1]);
    }

    // Test addRewriter method
    @Test
    public void test_addRewriter() {
        SearchHelper.SearchRequestParamsRewriter rewriter = p -> p;

        searchHelper.addRewriter(rewriter);

        assertNotNull(searchHelper.searchRequestParamsRewriters);
        assertTrue(searchHelper.searchRequestParamsRewriters.length > 0);
    }

        assertEquals(name, param.getName());
        assertNotNull(param.getValues());
        assertEquals(4, param.getValues().length);
        assertEquals("value1", param.getValues()[0]);
        assertNull(param.getValues()[1]);
        assertEquals("value3", param.getValues()[2]);
        assertNull(param.getValues()[3]);
    }

    @Test
    public void test_constructor_withSpecialCharacters() {

            .isSameInstanceAs(entry.getValue());
        Object newKey = new Object();
        assertThat(cache.asMap().putIfAbsent(newKey, entry.getValue())).isNull();
        // this getUnchecked() call shouldn't be a cache miss; verified below
        assertThat(cache.getUnchecked(entry.getKey())).isEqualTo(entry.getValue());
        assertThat(cache.getUnchecked(newKey)).isEqualTo(entry.getValue());
        // don't let the new entry get GCed

        assertEquals(expected, DocumentUtil.getValue(doc, "key1", String.class));
        assertEquals(Integer.parseInt(expected), DocumentUtil.getValue(doc, "key1", Integer.class).intValue());
        assertEquals(Long.parseLong(expected), DocumentUtil.getValue(doc, "key1", Long.class).longValue());
        assertEquals(Float.parseFloat(expected), DocumentUtil.getValue(doc, "key1", Float.class).floatValue());

        map.put("boost2", 0);
        assertTrue(0.0f == docBoostMatcher.getValue(map));

        map.put("boost1", 1);
        map.put("boost2", 0);
        assertTrue(10.0f == docBoostMatcher.getValue(map));

        map.put("boost1", 1);
        map.put("boost2", 2);
        assertTrue(12.0f == docBoostMatcher.getValue(map));
    }

    @Test
    public void test_getValue_floatReturn() {

      @Override
      @ParametricNullness
      V transform(Cell<R, C, V> cell) {
        return cell.getValue();
      }
    };
  }

  @GwtIncompatible // Spliterator
  Spliterator<V> valuesSpliterator() {
    return CollectSpliterators.map(cellSpliterator(), 0, Table.Cell::getValue);
  }

  @WeakOuter
  private final class Values extends AbstractCollection<V> {
    @Override

    assertThat(entry.getKey()).isEqualTo("foo");
    assertThat(entry.getValue()).containsExactly(1, 3, 7);
    entry = iterator.next();
    assertThat(entry.getKey()).isEqualTo("google");
    assertThat(entry.getValue()).containsExactly(2, 6);
    entry = iterator.next();
    assertThat(entry.getKey()).isEqualTo("tree");
    assertThat(entry.getValue()).containsExactly(0, 4);
  }

  public void testOrderedEntries() {

        return ImmutableMap.of(entry.getKey(), entry.getValue());
      default:
        Map<K, V> orderPreservingCopy = Maps.newLinkedHashMap();
        for (Entry<? extends K, ? extends V> e : map.entrySet()) {
          orderPreservingCopy.put(checkNotNull(e.getKey()), checkNotNull(e.getValue()));
        }
        return new RegularImmutableMap<K, V>(orderPreservingCopy);
    }
  }

        @Override
        public K getKey() {
          return ArrayMap.this.getKey(index);
        }

        @Override
        @ParametricNullness
        public V getValue() {
          return ArrayMap.this.getValue(index);
        }

        @Override
        @ParametricNullness
        public V setValue(@ParametricNullness V value) {
          return ArrayMap.this.setValue(index, value);