* returns the same bytes as the upstream source. Downstream sources may read data either as it
 * is returned by upstream, or after the upstream source has been exhausted.
 *
 * As bytes are returned from upstream they are written to a local file. Downstream sources read
 * from this file as necessary.
 *

        // After last element, hasNext should be false and calling close() should send Smb2CloseRequest once
        assertFalse(it.hasNext(), "Iterator should be exhausted");

        // Close explicitly to exercise doCloseInternal
        it.close();

        // Verify interactions: one create, two additional directory queries (for fetchMore), one close

        list += element
      }
      return list
    }

    private fun unescape(s: String): String =
      buildString {
        val buffer = Buffer().writeUtf8(s)
        while (!buffer.exhausted()) {
          val c = buffer.readUtf8CodePoint()
          if (c != '\\'.code) {
            append(c.toChar())
            continue
          }
          when (buffer.readUtf8CodePoint()) {

        assertTrue(it.hasNext());
        assertEquals("b", it.next().getName(), "Next element should skip '.' and '..'");
        assertFalse(it.hasNext(), "Iterator exhausted after valid entries");
        verify(tree, times(1)).release(); // closed after exhaustion
    }

    @ParameterizedTest
    @ValueSource(strings = { "", "file.txt", "subdir" })

        // Constructor gets entry1, first next() returns it and gets entry2,
        // second next() returns entry2 and gets entry3,
        // third next() returns entry3 and exhausts
        when(delegate.hasNext()).thenReturn(true, true, true, false);
        when(delegate.next()).thenReturn(entry1, entry2, entry3);

        TestIterator iterator = new TestIterator(null);

  fun sourceEmpty() {
    val mediaType = if (null == null) null else "any/thing; charset=${null}".toMediaType()
    val body = "".decodeHex().toResponseBody(mediaType)
    val source = body.source()
    assertThat(source.exhausted()).isTrue()
    assertThat(source.readUtf8()).isEqualTo("")
  }

  @Test
  fun sourceClosesUnderlyingSource() {
    var closed = false

    val body: ResponseBody =
      object : ResponseBody() {

    // Write each byte into a new buffer, then clone it so that the segments are shared.
    // Shared segments cannot be compacted so we'll get a long chain of short segments.
    val result = Buffer()
    while (!buffer.exhausted()) {
      val box = Buffer()
      box.write(buffer, 1)
      result.write(box.copy(), 1)
    }
    return result
  }

  tailrec fun File.isDescendentOf(directory: File): Boolean {

 *
 * <p>The value you pass to the parameter {@code steps} should be greater than the length of your
 * iterator, so that this class can check that your iterator behaves correctly when it is exhausted.
 *
 * <p>For example, to test {@link java.util.Collections#unmodifiableList(java.util.List)
 * Collections.unmodifiableList}'s iterator:
 *
 * {@snippet :
 * List<String> expectedElements =

    /**
     * Static factory for connection pool exhaustion
     */
    public static SmbResourceException connectionPoolExhausted(int errorCode, int poolSize) {
        return new SmbResourceException("Connection pool exhausted", errorCode, ResourceType.CONNECTION, 0, poolSize);
    }

    /**
     * Static factory for quota exceeded
     */
    public static SmbResourceException quotaExceeded(int errorCode, long used, long quota) {

      assertTrue(
          "index " + i + " expected <" + expected + "., actual is exhausted",
          actualIterator.hasNext());

      Object actual = actualIterator.next();
      assertEquals("index " + i, expected, actual);
      i++;
    }
    if (actualIterator.hasNext()) {
      fail("index " + i + ", expected is exhausted, actual <" + actualIterator.next() + ">");
    }
  }

  /**