return emptySet();
    } else {
      return emptyList();
    }
  }

  @Override
  public void clear() {
    keySet().clear();
  }

  @Override
  Set<K> createKeySet() {
    return Sets.filter(unfiltered.keySet(), keyPredicate);
  }

  @Override
  public Collection<V> get(@ParametricNullness K key) {
    if (keyPredicate.apply(key)) {

    return delegate().tailMap(fromKey);
  }

  /**
   * A sensible implementation of {@link SortedMap#keySet} in terms of the methods of {@code
   * ForwardingSortedMap}. In many cases, you may wish to override {@link
   * ForwardingSortedMap#keySet} to forward to this implementation or a subclass thereof.
   *
   * @since 15.0
   */

    #    ; map:{code=0; name=False; alias=Unchecked; comment=means no ; sisterCode=false}
    #}
    # example for table classification
    #; MemberStatus = list:{
    #    ; map:{topComment=status of member from entry to withdrawal; codeType=String}
    #    ; map:{
    #        ; table=MEMBER_STATUS
    #        ; code=MEMBER_STATUS_CODE; name=MEMBER_STATUS_NAME
    #        ; comment=DESCRIPTION; orderBy=DISPLAY_ORDER

    }

    @Override
    public int hashCode() {
      return standardHashCode();
    }

    @Override
    public Set<K> keySet() {
      /*
       * We can't use StandardKeySet, as NavigableMapTestSuiteBuilder assumes that our keySet is a
       * NavigableSet. We test StandardKeySet in the superclass, so it's still covered.
       */
      return navigableKeySet();
    }

    @Override

        parent.putAll(m);
    }

    @Override
    public void clear() {
        parent.clear();
    }

    @Override
    public Set<K> keySet() {
        // return original keys
        return parent.keySet();
    }

    @Override
    public Collection<V> values() {
        return parent.values();
    }

    @Override
    public Set<Entry<K, V>> entrySet() {

    return Maps.safeContainsKey(columnMap(), columnKey);
  }

  @Override
  public Set<R> rowKeySet() {
    return rowMap().keySet();
  }

  @Override
  public Set<C> columnKeySet() {
    return columnMap().keySet();
  }

  @Override
  public boolean containsValue(@Nullable Object value) {
    for (Map<C, V> row : rowMap().values()) {
      if (row.containsValue(value)) {

    return delegate().tailMap(fromKey);
  }

  /**
   * A sensible implementation of {@link SortedMap#keySet} in terms of the methods of {@code
   * ForwardingSortedMap}. In many cases, you may wish to override {@link
   * ForwardingSortedMap#keySet} to forward to this implementation or a subclass thereof.
   *
   * @since 15.0
   */

                context.failure("Strategy failed: " + e.getMessage());
                // Mark all POMs as having errors for this strategy
                UpgradeResult errorResult = new UpgradeResult(pomMap.keySet(), java.util.Set.of(), pomMap.keySet());
                overallResult = overallResult.merge(errorResult);
            } finally {
                context.unindent();
                context.println();
            }
        }

    cache.getUnchecked(one);
    Map<Object, Object> newMap = ImmutableMap.of(one, one);
    assertThat(map).isEqualTo(newMap);
    assertThat(map.entrySet()).isEqualTo(newMap.entrySet());
    assertThat(map.keySet()).isEqualTo(newMap.keySet());
    Set<Object> expectedValues = ImmutableSet.of(one);
    Set<Object> actualValues = ImmutableSet.copyOf(map.values());
    assertThat(actualValues).isEqualTo(expectedValues);
  }

    cache.getUnchecked(one);
    Map<Object, Object> newMap = ImmutableMap.of(one, one);
    assertThat(map).isEqualTo(newMap);
    assertThat(map.entrySet()).isEqualTo(newMap.entrySet());
    assertThat(map.keySet()).isEqualTo(newMap.keySet());
    Set<Object> expectedValues = ImmutableSet.of(one);
    Set<Object> actualValues = ImmutableSet.copyOf(map.values());
    assertThat(actualValues).isEqualTo(expectedValues);
  }