}

  @Override
  public NavigableSet<E> subSet(
      E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
    return new SafeTreeSet<>(
        delegate.subSet(
            checkValid(fromElement), fromInclusive, checkValid(toElement), toInclusive));
  }

  @Override
  public SortedSet<E> subSet(E fromElement, E toElement) {
    return subSet(fromElement, true, toElement, false);
  }

    powerSet = Sets.powerSet(set);
  }

  @Benchmark
  int iteration(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {
      for (Set<Integer> subset : powerSet) {
        for (Integer value : subset) {
          sum += value;
        }
      }
    }
    return sum;
  }

      } else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) {
        return set.subSet(firstExclusive, false, lastExclusive, false);
      } else if (from == Bound.EXCLUSIVE && to == Bound.INCLUSIVE) {
        return set.subSet(firstExclusive, false, lastInclusive, true);
      } else if (from == Bound.INCLUSIVE && to == Bound.INCLUSIVE) {
        return set.subSet(firstInclusive, true, lastInclusive, true);
      } else {

                    }
                  },
                  MoreExecutors.directExecutor());
            })
        .then(onFulfilled, onRejected);
  }
}

/**
 * Subset of the elemental2 IThenable interface without the single-parameter overload, which allows
 * us to implement it using a default implementation in J2cl ListenableFuture.
 */

    if (features.remove(CollectionFeature.ALLOWS_NULL_VALUES)) {
      // the null value might be out of bounds, so we can't always construct a subset with nulls
      features.add(CollectionFeature.ALLOWS_NULL_QUERIES);
      // but add null might still be supported if it happens to be within range of the subset
      suppressing.add(CollectionAddTester.getAddNullUnsupportedMethod());

    if (features.remove(CollectionFeature.ALLOWS_NULL_VALUES)) {
      // the null value might be out of bounds, so we can't always construct a subset with nulls
      features.add(CollectionFeature.ALLOWS_NULL_QUERIES);
      // but add null might still be supported if it happens to be within range of the subset
      suppressing.add(CollectionAddTester.getAddNullUnsupportedMethod());

                    set.addAll(difference);
                    Set<String> subset = newHashSet(samples());
                    subset.removeAll(difference);
                    return difference(set, subset);
                  }
                })
            .named("set - subset")
            .withFeatures(

         * greater than tooHigh.
         */
        return ContiguousSet.create(Range.openClosed(0, 1), DiscreteDomain.integers()).subSet(0, 1);
      }
      int tooHigh = set.last() + 1;
      int tooLow = set.first() - 1;
      set.add(tooHigh);
      set.add(tooLow);
      return checkedCreate(set).subSet(tooLow + 1, tooHigh);
    }
  }

  @GwtIncompatible // NavigableSet

        for (int i = 0; i < 10; i++) {
          for (int j = i; j < 10; j++) {
            assertEquals(
                filter((C) createUnfiltered(contents).subSet(i, j), EVEN),
                filter(createUnfiltered(contents), EVEN).subSet(i, j));
          }
        }
      }
    }
  }

  public abstract static class AbstractFilteredNavigableSetTest

    }

    @Override
    public NavigableSet<E> subSet(
        @ParametricNullness E fromElement,
        boolean fromInclusive,
        @ParametricNullness E toElement,
        boolean toInclusive) {
      return forward.subSet(toElement, toInclusive, fromElement, fromInclusive).descendingSet();
    }

    @Override
    public SortedSet<E> subSet(@ParametricNullness E fromElement, @ParametricNullness E toElement) {