log.warn("Disconnected tree while still in use " + this);
                        dumpResource();
                        wasInUse = true;
                        if (sess.getConfig().isTraceResourceUsage()) {
                            throw new RuntimeCIFSException("Disconnected tree while still in use");
                        }
                    }

internal const val TYPE_DISALLOWED_STD3_VALID = 3
internal const val TYPE_IGNORED = 4
internal const val TYPE_MAPPED = 5
internal const val TYPE_VALID = 6

private fun BufferedSource.skipWhitespace() {
  while (!exhausted()) {
    if (buffer[0] != ' '.code.toByte()) return
    skip(1L)
  }
}

private fun BufferedSource.skipRestOfLine() {
  when (val newline = indexOf('\n'.code.toByte())) {

            urlQueueList.add(urlQueue);
        }

        urlQueueService.offerAll(sessionId, urlQueueList);

        // Poll all items
        int count = 0;
        while (true) {
            final OpenSearchUrlQueue polled = urlQueueService.poll(sessionId);
            if (polled == null) {
                break;
            }
            count++;

    long count = 0;
    long skipped;
    while ((skipped = skipUpTo(in, Integer.MAX_VALUE)) > 0) {
      count += skipped;
    }
    return count;
  }

  /**
   * Copies the contents of this byte source to the given {@code OutputStream}. Does not close
   * {@code output}.
   *
   * @return the number of bytes copied
   * @throws IOException if an I/O error occurs while reading from this source or writing to {@code

            assertNotNull(child, "Child resource should not be null");
            assertSame(expectedChild, child, "Should return expected child resource");
        }
    }

    @Nested
    @DisplayName("File Attribute Tests")
    class FileAttributeTests {

        @Test
        @DisplayName("file type checks should work correctly")
        void testFileTypeChecks() throws CIFSException {
            // Given

    assertFullyRead(reader);

    // read in chunks to fixed array
    reader = new CharSequenceReader(charSequence);
    buf = new char[5];
    StringBuilder builder = new StringBuilder();
    int read;
    while ((read = reader.read(buf, 0, buf.length)) != -1) {
      builder.append(buf, 0, read);
    }
    assertEquals(expected, builder.toString());
    assertFullyRead(reader);

    // read all to one CharBuffer

        }
        final StringBuilder buffer = new StringBuilder((int) Math.ceil(length / 3d) * 4);
        final int remainder = length % 3;
        length -= remainder;
        int block;
        int i = 0;
        while (i < length) {
            block = (bytes[i++] & 0xff) << 16 | (bytes[i++] & 0xff) << 8 | bytes[i++] & 0xff;
            buffer.append(ALPHABET.charAt(block >>> 18));
            buffer.append(ALPHABET.charAt(block >>> 12 & 0x3f));

@J2ktIncompatible
final class Serialization {
  private Serialization() {}

  /**
   * Stores the contents of a map in an output stream, as part of serialization. It does not support
   * concurrent maps whose content may change while the method is running.
   *
   * <p>The serialized output consists of the number of entries, first key, first value, second key,
   * second value, and so on.
   */

    Interruptenator(Thread interruptee, long everyMillis) {
      this.everyMillis = everyMillis;
      this.interruptee = interruptee;
    }

    @Override
    public void run() {
      while (true) {
        try {
          Thread.sleep(everyMillis);
        } catch (InterruptedException e) {
          // ok. just stop sleeping.
        }
        if (shouldStop) {
          break;
        }

      }
      List<Element> tmp = new ArrayList<>(elementsInSet);
      shuffle(tmp, random);
      queryList.addAll(tmp.subList(0, extras));
    }

    // now add bad queries
    while (queryList.size() < numQueries) {
      Element candidate = newElement();
      if (!elementsInSet.contains(candidate)) {
        queryList.add(candidate);
      }
    }
    shuffle(queryList, random);