*   <li>{@code proxy.toString()} delegates to {@link AbstractInvocationHandler#toString}
   *   <li>{@code proxy.equals(argument)} returns true if:
   *       <ul>
   *         <li>{@code proxy} and {@code argument} are of the same type
   *         <li>and {@link AbstractInvocationHandler#equals} returns true for the {@link
   *             InvocationHandler} of {@code argument}
   *       </ul>

internal fun String.containsInvalidLabelLengths(): Boolean {
  if (length !in 1..253) return true

  var labelStart = 0
  while (true) {
    val dot = indexOf('.', startIndex = labelStart)
    val labelLength =
      when (dot) {
        -1 -> length - labelStart
        else -> dot - labelStart
      }
    if (labelLength !in 1..63) return true
    if (dot == -1) break
    if (dot == length - 1) break // Trailing '.' is allowed.

        assertEquals(expectedSet.subSet(i, true, j, false), asSet.subSet(i, true, j, false));
        assertEquals(expectedSet.subSet(i, false, j, true), asSet.subSet(i, false, j, true));
        assertEquals(expectedSet.subSet(i, true, j, true), asSet.subSet(i, true, j, true));
      }
    }
  }

  public void testSubRangeSet() {

    monitor.enter();
    try {
      verifyOccupiedMethodsInCurrentThread(monitor, true, true, 1);
      verifyOccupiedMethodsInAnotherThread(monitor, true, false, 0);
      monitor.enter();
      try {
        verifyOccupiedMethodsInCurrentThread(monitor, true, true, 2);
        verifyOccupiedMethodsInAnotherThread(monitor, true, false, 0);
      } finally {
        monitor.leave();
      }

    monitor.enter();
    try {
      verifyOccupiedMethodsInCurrentThread(monitor, true, true, 1);
      verifyOccupiedMethodsInAnotherThread(monitor, true, false, 0);
      monitor.enter();
      try {
        verifyOccupiedMethodsInCurrentThread(monitor, true, true, 2);
        verifyOccupiedMethodsInAnotherThread(monitor, true, false, 0);
      } finally {
        monitor.leave();
      }

  //
  // Network properties
  //

  /**
   * Returns true if the edges in this network are directed. Directed edges connect a {@link
   * EndpointPair#source() source node} to a {@link EndpointPair#target() target node}, while
   * undirected edges connect a pair of nodes to each other.
   */
  boolean isDirected();

  /**
   * Returns true if this network allows parallel edges. Attempting to add a parallel edge to a

    }

    private boolean processEOF() {
        if (peekc < 0) {
            ttype = TT_EOF;
            return true;
        }
        if (peekc == NEED_CHAR) {
            peekc = read();
            if (peekc < 0) {
                ttype = TT_EOF;
                return true;
            }
        }
        return false;
    }

    private boolean processWhitespace() {

                return false;
            }
        }
        if (this.nameFilter == null) {
            return true;
        }
        try {
            if (!this.nameFilter.accept(this.parent, name)) {
                return false;
            }
            return true;
        } catch (final CIFSException e) {
            log.error("Failed to apply name filter", e);
            return false;

  @GwtIncompatible // concurrency
  public static void awaitUninterruptibly(CountDownLatch latch) {
    boolean interrupted = false;
    try {
      while (true) {
        try {
          latch.await();
          return;
        } catch (InterruptedException e) {
          interrupted = true;
        }
      }
    } finally {
      if (interrupted) {
        Thread.currentThread().interrupt();
      }
    }
  }

  /**

        assertThat(map.isEmpty(), is(not(true)));
        map.clear();
        assertThat(map.isEmpty(), is(true));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testContainsValue() throws Exception {
        assertThat(map.containsValue("test2"), is(true));
        assertThat(map.containsValue("test3"), is(not(true)));
    }

    /**
     * @throws Exception