RangeListCodePointSet(
        ranges =
          mutableListOf<IntRange>()
            .apply {
              addAll(readCodePointSet(base / "rfc3454.C.1.2.txt").ranges)
              addAll(readCodePointSet(base / "rfc3454.C.2.2.txt").ranges)
              addAll(readCodePointSet(base / "rfc3454.C.3.txt").ranges)
              addAll(readCodePointSet(base / "rfc3454.C.4.txt").ranges)

    for (Range<Integer> range : RANGES) {
      Map<Integer, Integer> model = Maps.newHashMap();
      putModel(model, range, 1);
      RangeMap<Integer, Integer> test = TreeRangeMap.create();
      test.put(range, 1);
      verify(model, test);
    }
  }

  public void testAllRangePairs() {
    for (Range<Integer> range1 : RANGES) {
      for (Range<Integer> range2 : RANGES) {

  return result.toMap()
}

/**
 * Modifies [ranges] to combine any adjacent [MappedRange.InlineDelta] of same size to single entry.
 * @returns same instance of [ranges] for convenience
 */
internal fun mergeAdjacentDeltaMappedRanges(ranges: MutableList<MappedRange>): MutableList<MappedRange> {
  var i = 0
  while (i < ranges.size) {
    val curr = ranges[i]
    if (curr is MappedRange.InlineDelta) {
      val j = i + 1

    for (Range<Integer> range : RANGES) {
      Map<Integer, Integer> model = Maps.newHashMap();
      putModel(model, range, 1);
      RangeMap<Integer, Integer> test = TreeRangeMap.create();
      test.put(range, 1);
      verify(model, test);
    }
  }

  public void testAllRangePairs() {
    for (Range<Integer> range1 : RANGES) {
      for (Range<Integer> range2 : RANGES) {

/**
 * A set comprising zero or more {@linkplain Range#isEmpty nonempty}, {@linkplain
 * Range#isConnected(Range) disconnected} ranges of type {@code C}.
 *
 * <p>Implementations that choose to support the {@link #add(Range)} operation are required to
 * ignore empty ranges and coalesce connected ranges. For example:
 *
 * <pre>{@code
 * RangeSet<Integer> rangeSet = TreeRangeSet.create();
 * rangeSet.add(Range.closed(1, 10)); // {[1, 10]}

    } else {
      Range<K> range = ranges.get(index);
      return range.contains(key) ? Maps.immutableEntry(range, values.get(index)) : null;
    }
  }

  @Override
  public Range<K> span() {
    if (ranges.isEmpty()) {
      throw new NoSuchElementException();
    }
    Range<K> firstRange = ranges.get(0);
    Range<K> lastRange = ranges.get(ranges.size() - 1);

  public boolean enclosesAll(Iterable<Range<C>> ranges) {
    for (Range<C> range : ranges) {
      if (!encloses(range)) {
        return false;
      }
    }
    return true;
  }

  @Override
  public void addAll(RangeSet<C> other) {
    addAll(other.asRanges());
  }

  @Override
  public void addAll(Iterable<Range<C>> ranges) {
    for (Range<C> range : ranges) {
      add(range);
    }
  }

    assertThat(compactTable.ranges.length).isLessThan((1 shl 14) * 4)

    // Less than 16,384 chars, because we index on a 14-bit index in the ranges table.
    assertThat(compactTable.mappings.length).isLessThan(1 shl 14)

    // Confirm the data strings are ASCII.
    for (dataString in listOf<String>(compactTable.sections, compactTable.ranges)) {
      for (codePoint in dataString.codePoints()) {

    assertThat((nameprep.unassigned as RangeListCodePointSet).ranges).hasSize(396)
    assertThat((nameprep.mapping as MappingListCodePointMapping).mappings).hasSize(1398)
    assertThat((nameprep.prohibitSet as RangeListCodePointSet).ranges).hasSize(78)
    assertThat((nameprep.randalcatSet as RangeListCodePointSet).ranges).hasSize(34)
    assertThat((nameprep.lcatSet as RangeListCodePointSet).ranges).hasSize(360)
  }

  @Test fun readCodePointSet() {

      }
    }
    ImmutableList<Range<Integer>> ranges = rangesBuilder.build();
    for (int i = -2; i <= 2; i++) {
      rangesBuilder.add(Range.closedOpen(i, i));
      rangesBuilder.add(Range.openClosed(i, i));
    }
    ImmutableList<Range<Integer>> subRanges = rangesBuilder.build();
    for (Range<Integer> range1 : ranges) {
      for (Range<Integer> range2 : ranges) {