GeneralRange.upTo(Ordering.natural(), 3, endpointType),
          GeneralRange.from(Range.upTo(3, endpointType)));

      assertEquals(
          GeneralRange.downTo(Ordering.natural(), 3, endpointType),
          GeneralRange.from(Range.downTo(3, endpointType)));
    }
  }

  public void testFromRangeTwoEnds() {
    for (BoundType lowerType : BoundType.values()) {

          GeneralRange.upTo(Ordering.natural(), 3, endpointType),
          GeneralRange.from(Range.upTo(3, endpointType)));

      assertEquals(
          GeneralRange.downTo(Ordering.natural(), 3, endpointType),
          GeneralRange.from(Range.downTo(3, endpointType)));
    }
  }

  public void testFromRangeTwoEnds() {
    for (BoundType lowerType : BoundType.values()) {

      append("\n")
    }
  }

internal fun commonHeadersGet(
  namesAndValues: Array<String>,
  name: String,
): String? {
  for (i in namesAndValues.size - 2 downTo 0 step 2) {
    if (name.equals(namesAndValues[i], ignoreCase = true)) {
      return namesAndValues[i + 1]
    }
  }
  return null
}

internal fun Headers.Builder.commonAdd(
  name: String,

    this.withLock {
      return busyQueues + readyQueues
    }
  }

  fun cancelAll() {
    assertLockHeld()
    for (i in busyQueues.size - 1 downTo 0) {
      busyQueues[i].cancelAllAndDecide()
    }
    for (i in readyQueues.size - 1 downTo 0) {
      val queue = readyQueues[i]
      queue.cancelAllAndDecide()
      if (queue.futureTasks.isEmpty()) {
        readyQueues.removeAt(i)
      }
    }

      return subMap(Range.upTo(toKey, BoundType.forBoolean(inclusive)));
    }

    @Override
    public NavigableMap<Cut<C>, Range<C>> tailMap(Cut<C> fromKey, boolean inclusive) {
      return subMap(Range.downTo(fromKey, BoundType.forBoolean(inclusive)));
    }

    @Override
    public Comparator<? super Cut<C>> comparator() {
      return Ordering.<Cut<C>>natural();
    }

    @Override

 */
internal fun String.indexOfLastNonAsciiWhitespace(
  startIndex: Int = 0,
  endIndex: Int = length,
): Int {
  for (i in endIndex - 1 downTo startIndex) {
    when (this[i]) {
      '\t', '\n', '\u000C', '\r', ' ' -> Unit
      else -> return i + 1
    }
  }
  return startIndex
}

  }

  public void testEquivalentFactories() {
    new EqualsTester()
        .addEqualityGroup(Range.all())
        .addEqualityGroup(Range.atLeast(1), Range.downTo(1, CLOSED))
        .addEqualityGroup(Range.greaterThan(1), Range.downTo(1, OPEN))
        .addEqualityGroup(Range.atMost(7), Range.upTo(7, CLOSED))
        .addEqualityGroup(Range.lessThan(7), Range.upTo(7, OPEN))

            toElement, BoundType.forBoolean(toInclusive)));
  }

  @Override
  ContiguousSet<C> tailSetImpl(C fromElement, boolean inclusive) {
    return intersectionInCurrentDomain(Range.downTo(fromElement, BoundType.forBoolean(inclusive)));
  }

  @GwtIncompatible // not used by GWT emulation
  @Override
  int indexOf(@Nullable Object target) {
    if (!contains(target)) {
      return -1;
    }

  }

  public void testEquivalentFactories() {
    new EqualsTester()
        .addEqualityGroup(Range.all())
        .addEqualityGroup(Range.atLeast(1), Range.downTo(1, CLOSED))
        .addEqualityGroup(Range.greaterThan(1), Range.downTo(1, OPEN))
        .addEqualityGroup(Range.atMost(7), Range.upTo(7, CLOSED))
        .addEqualityGroup(Range.lessThan(7), Range.upTo(7, OPEN))

  internal fun cancelAllAndDecide(): Boolean {
    if (activeTask != null && activeTask!!.cancelable) {
      cancelActiveTask = true
    }

    var tasksCanceled = false
    for (i in futureTasks.size - 1 downTo 0) {
      if (futureTasks[i].cancelable) {
        taskRunner.logger.taskLog(futureTasks[i], this) { "canceled" }
        tasksCanceled = true
        futureTasks.removeAt(i)
      }
    }