return hashPath(d.Info.Name)
}

// clone returns a copy of the cache with no references to the existing.
func (d *dataUsageCache) clone() dataUsageCache {
	clone := dataUsageCache{
		Info:  d.Info,
		Cache: make(map[string]dataUsageEntry, len(d.Cache)),
	}
	for k, v := range d.Cache {
		clone.Cache[k] = v.clone()
	}
	return clone
}

// merge root of other into d.

        // Close should have sent FindClose2 exactly once
        ArgumentCaptor<SmbComFindClose2> captor = ArgumentCaptor.forClass(SmbComFindClose2.class);
        verify(tree, times(1)).send(captor.capture(), any());
        assertNotNull(captor.getValue());

        // Tree handle is released after close
        verify(tree, atLeastOnce()).release();
    }

    @Test

		case <-t.C:
			last := time.Since(time.Unix(atomic.LoadInt64(&m.LastPing), 0))
			if last > 4*m.clientPingInterval {
				gridLogIf(m.ctx, fmt.Errorf("canceling remote connection %s not seen for %v", m.parent, last))
				m.close()
				return
			}
		}
	}
}

// checkSeq will check if sequence number is correct and increment it by 1.
func (m *muxServer) checkSeq(seq uint32) (ok bool) {
	if seq != m.RecvSeq {

        final String content = "Small content";
        final FileOutputStream out = new FileOutputStream(file);
        try {
            out.write(content.getBytes("UTF-8"));
        } finally {
            out.close();
        }

        // Set maxSize larger than file size
        final byte[] bytes = FileUtil.readBytes(file, 1024);
        assertThat(new String(bytes, "UTF-8"), is(content));
    }

    /**

                fos = null; // Successfully wrapped, no need to close explicitly
            } catch (final Exception e) {
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (final IOException ioe) {
                        // Ignore close exception
                    }
                }
                if (newFile != null) {

    assertThat(c0e0.exchangeIndex).isEqualTo(0)
    val c0e1 = server.takeRequest()
    assertThat(c0e1.connectionIndex).isEqualTo(0)
    assertThat(c0e1.exchangeIndex).isEqualTo(1)
    response1.close()
    response2.close()
  }

  @Test
  fun connectionWindowUpdateAfterCanceling() {
    server.enqueue(
      MockResponse
        .Builder()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  private var client = clientTestRule.newClient()

  @AfterEach internal fun tearDown() {
    factory.close()
  }

  @Test fun nonRetryableIOException() {
    val exception = IOException("Non-handshake exception")
    assertThat(retryTlsHandshake(exception)).isFalse()
  }

        stream.read(); // Read some data
        stream.close();

        // Note: FileUtil.deleteInBackground() performs deletion asynchronously,
        // so we cannot reliably check if file is deleted immediately
        // This test just verifies that close() completes without error
    }

    public void test_emptyFile() throws Exception {

    # Manually add the screenshot
    page.screenshot(path="docs/en/docs/img/tutorial/header-param-models/image01.png")

    # ---------------------
    context.close()
    browser.close()


process = subprocess.Popen(
    ["fastapi", "run", "docs_src/header_param_models/tutorial001.py"]
)
try:
    for _ in range(3):
        try:

    # Manually add the screenshot
    page.screenshot(path="docs/en/docs/img/tutorial/request-form-models/image01.png")

    # ---------------------
    context.close()
    browser.close()


process = subprocess.Popen(
    ["fastapi", "run", "docs_src/request_form_models/tutorial001.py"]
)
try:
    for _ in range(3):
        try: