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;

        assertNotNull(task);
        assertNotNull(task.getValue1());
        assertNotNull(task.getValue2());
        assertNotNull(task.getValue3());
        assertEquals("task-id", task.getValue1());
        assertEquals(path, task.getValue2());
        assertEquals("application/pdf", task.getValue3());
    }

    @Test
    public void test_createTask_withNullPath() {

        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());

    }

    @Test
    public void test_getValue() {
        assertEquals("search", ChatIntent.SEARCH.getValue());
        assertEquals("summary", ChatIntent.SUMMARY.getValue());
        assertEquals("faq", ChatIntent.FAQ.getValue());
        assertEquals("unclear", ChatIntent.UNCLEAR.getValue());
    }

    @Test
    public void test_fromValue_search() {

        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() {