public void testToImmutableTableSanityTest() {
    Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> collector =
        toImmutableTable(Cell::getRowKey, Cell::getColumnKey, Cell::getValue);
    CollectorTester.of(collector)
        .expectCollects(ImmutableTable.of())
        .expectCollects(ImmutableTable.of("one", "uno", 1), immutableCell("one", "uno", 1));
  }

                    Map<String, String> map = CompactLinkedHashMap.create();
                    for (Entry<String, String> entry : entries) {
                      map.put(entry.getKey(), entry.getValue());
                    }
                    return map;
                  }
                })
            .named("CompactLinkedHashMap")
            .withFeatures(
                CollectionSize.ANY,

                getAliasesResponse.getAliases().entrySet().forEach(
                        x -> x.getValue().stream().filter(y -> updateAlias.equals(y.alias())).forEach(y -> updateIndices.add(x.getKey())));
            }
            if (updateIndices.size() != 1) {
                if (logger.isDebugEnabled()) {

    this.singleColumnKey = checkNotNull(columnKey);
    this.singleValue = checkNotNull(value);
  }

  SingletonImmutableTable(Cell<R, C, V> cell) {
    this(cell.getRowKey(), cell.getColumnKey(), cell.getValue());
  }

  @Override
  public ImmutableMap<R, V> column(C columnKey) {
    checkNotNull(columnKey);
    return containsColumn(columnKey)
        ? ImmutableMap.of(singleRowKey, singleValue)

                if ("overwrite".equalsIgnoreCase(value)) {
                    return true;
                }
            }
            return false;
        }

        public String[] getValues() {
            return values;
        }
    }

    K key1 = entry1.getKey();
    V value1 = entry1.getValue();
    checkEntryNotNull(key1, value1);
    // Do something that works for j2cl, where we can't call getDeclaredClass():
    EnumMap<K, V> enumMap = new EnumMap<>(singletonMap(key1, value1));
    while (entryItr.hasNext()) {
      Entry<K, ? extends V> entry = entryItr.next();
      K key = entry.getKey();
      V value = entry.getValue();
      checkEntryNotNull(key, value);

    K key1 = entry1.getKey();
    V value1 = entry1.getValue();
    checkEntryNotNull(key1, value1);
    // Do something that works for j2cl, where we can't call getDeclaredClass():
    EnumMap<K, V> enumMap = new EnumMap<>(singletonMap(key1, value1));
    while (entryItr.hasNext()) {
      Entry<K, ? extends V> entry = entryItr.next();
      K key = entry.getKey();
      V value = entry.getValue();
      checkEntryNotNull(key, value);

    K key = secondEntry.getKey();
    SortedMap<K, V> subMap = map.tailMap(key);
    V value = getValueNotInPopulatedMap();
    subMap.put(key, value);
    assertEquals(secondEntry.getValue(), value);
    assertEquals(map.get(key), value);
    assertThrows(IllegalArgumentException.class, () -> subMap.put(firstEntry.getKey(), value));
  }

  public void testTailMapRemoveThrough() {
    SortedMap<K, V> map;

                log.trace("  Root " + entry2.getKey());
                if ( entry2.getValue().map != null ) {
                    for ( Entry<String, DfsReferralDataInternal> entry3 : entry2.getValue().map.entrySet() ) {
                        DfsReferralDataInternal start = entry3.getValue();
                        DfsReferralDataInternal r = start;

        final Map<String, List<String>> params = new HashMap<>();
        for (final Map.Entry<String, String[]> e : request.getParameterMap().entrySet()) {
            if (e.getValue().length > 0) {
                params.put(e.getKey(), Arrays.asList(e.getValue()));
            }
        }
        if (logger.isDebugEnabled()) {
            logger.debug("process authentication: url: {}, params: {}", urlBuf, params);
        }