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

    // Test addRewriter method
    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]);
    }

    public void test_constructor_withSpecialCharacters() {

  }

  protected final V v0() {
    return e0().getValue();
  }

  protected final K k1() {
    return e1().getKey();
  }

  protected final V v1() {
    return e1().getValue();
  }

  protected final K k2() {
    return e2().getKey();
  }

  protected final V v2() {
    return e2().getValue();
  }

  protected final K k3() {
    return e3().getKey();

    assertEqualIgnoringOrder(getMap().inverse().entrySet(), reversedEntries);

    for (Entry<K, V> entry : expected) {
      assertEquals(
          "Wrong key for value " + entry.getValue(),
          entry.getKey(),
          getMap().inverse().get(entry.getValue()));
    }
  }

  @Override
  protected void expectMissing(Entry<K, V>... entries) {
    super.expectMissing(entries);
    for (Entry<K, V> entry : entries) {

      Range<K> range, V value, @Nullable Entry<Cut<K>, RangeMapEntry<K, V>> entry) {
    if (entry != null
        && entry.getValue().getKey().isConnected(range)
        && entry.getValue().getValue().equals(value)) {
      return range.span(entry.getValue().getKey());
    }
    return range;
  }

  @Override
  public void putAll(RangeMap<K, ? extends V> rangeMap) {

        assertSame(entry.getValue(), cache.asMap().putIfAbsent(entry.getKey(), newValue));
        Object newKey = new Object();
        assertNull(cache.asMap().putIfAbsent(newKey, entry.getValue()));
        // this getUnchecked() call shouldn't be a cache miss; verified below
        assertEquals(entry.getValue(), cache.getUnchecked(entry.getKey()));
        assertEquals(entry.getValue(), cache.getUnchecked(newKey));

      this.samples =
          new SampleElements<>(
              mapSamples.e0().getValue(),
              mapSamples.e1().getValue(),
              mapSamples.e2().getValue(),
              mapSamples.e3().getValue(),
              mapSamples.e4().getValue());
    }

    @Override
    public SampleElements<V> samples() {
      return samples;
    }

    @Override

                try {
                    list.add(new LabelTypePattern(labelType.getValue(), includedPaths, excludedPaths));
                } catch (final Exception e) {
                    logger.warn("Failed to create a matching pattern of a label: {}, includedPaths:{}, excludedPaths:{}",
                            labelType.getValue(), includedPaths, excludedPaths, e);
                }
            }
        }

    assertEqualIgnoringOrder(getMap().inverse().entrySet(), reversedEntries);

    for (Entry<K, V> entry : expected) {
      assertEquals(
          "Wrong key for value " + entry.getValue(),
          entry.getKey(),
          getMap().inverse().get(entry.getValue()));
    }
  }

  @Override
  protected void expectMissing(Entry<K, V>... entries) {
    super.expectMissing(entries);
    for (Entry<K, V> entry : entries) {

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

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

  @WeakOuter
  private final class Values extends AbstractCollection<V> {
    @Override
    public Iterator<V> iterator() {