assertTrue(rangeSet.intersects(Range.greaterThan(1)));
    assertFalse(rangeSet.intersects(Range.greaterThan(3)));

    assertTrue(rangeSet.encloses(Range.closed(2, 3)));
    assertTrue(rangeSet.encloses(Range.lessThan(1)));
    assertFalse(rangeSet.encloses(Range.closedOpen(1, 5)));

    assertTrue(rangeSet.contains(3));
    assertTrue(rangeSet.contains(0));

    assertThat(rangeSet.asRanges()).isEmpty();
    assertThat(rangeSet.complement().asRanges()).containsExactly(Range.<Integer>all());
  }

  public void testFillHoleExactly() {
    TreeRangeSet<Integer> rangeSet = TreeRangeSet.create();
    rangeSet.add(Range.closedOpen(1, 3));
    rangeSet.add(Range.closedOpen(4, 6));
    rangeSet.add(Range.closedOpen(3, 4));
    testInvariants(rangeSet);

  }

  /** Returns an immutable copy of the specified {@code RangeSet}. */
  public static <C extends Comparable> ImmutableRangeSet<C> copyOf(RangeSet<C> rangeSet) {
    checkNotNull(rangeSet);
    if (rangeSet.isEmpty()) {
      return of();
    } else if (rangeSet.encloses(Range.<C>all())) {
      return all();
    }

    if (rangeSet instanceof ImmutableRangeSet) {

    }
    RegularImmutableSortedSet<Range<K>> rangeSet =
        new RegularImmutableSortedSet<>(ranges, Range.<K>rangeLexOrdering());
    return new ImmutableSortedMap<>(rangeSet, values);
  }

  @Override
  public ImmutableMap<Range<K>, V> asDescendingMapOfRanges() {
    if (ranges.isEmpty()) {
      return ImmutableMap.of();
    }
    RegularImmutableSortedSet<Range<K>> rangeSet =

      @Override
      <K extends Comparable<K>> RangeSet<K> create(RangeSet<K> contents) {
        return TreeRangeSet.create(contents);
      }
    },
    ImmutableRangeSetImpl {
      @Override
      <K extends Comparable<K>> RangeSet<K> create(RangeSet<K> contents) {
        return ImmutableRangeSet.copyOf(contents);
      }
    };

    abstract <K extends Comparable<K>> RangeSet<K> create(RangeSet<K> contents);
  }

      @Override
      <K extends Comparable<K>> RangeSet<K> create(RangeSet<K> contents) {
        return TreeRangeSet.create(contents);
      }
    },
    ImmutableRangeSetImpl {
      @Override
      <K extends Comparable<K>> RangeSet<K> create(RangeSet<K> contents) {
        return ImmutableRangeSet.copyOf(contents);
      }
    };

    abstract <K extends Comparable<K>> RangeSet<K> create(RangeSet<K> contents);
  }