logger.warn("clientConnectionManager is null.");
            return;
        }

        try {
            // Close expired connections
            clientConnectionManager.closeExpiredConnections();
            // Close idle connections
            clientConnectionManager.closeIdleConnections(idleConnectionTimeout, TimeUnit.MILLISECONDS);
        } catch (final Exception e) {

			<div class="modal-content bg-danger">
				<div class="modal-header">
					<h4 class="modal-title">
						<la:message key="labels.crud_title_delete" />
					</h4>
					<button type="button" class="close" data-dismiss="modal"
						aria-label="Close">
						<span aria-hidden="true">×</span>
					</button>
				</div>
				<div class="modal-body">
					<p>
						<la:message key="labels.crud_delete_confirmation" />
					</p>
				</div>

            super.write(source, byteCount)
            totalBytesWritten += byteCount
            progressListener.update(totalBytesWritten, contentLength(), completed)
          }

          override fun close() {
            super.close()
            if (!completed) {
              completed = true
              progressListener.update(totalBytesWritten, contentLength(), completed)
            }
          }
        }

	finished := make(chan struct{})
	go func() {
		globalMRFState.shutdown()
		close(finished)
	}()
	select {
	case <-time.After(shutdownTimeout):
	case <-finished:
	}
}

func handleSignals() {
	// Custom exit function
	exit := func(success bool) {
		if globalLoggerOutput != nil {
			globalLoggerOutput.Close()
		}

		// If global profiler is set stop before we exit.
		globalProfilerMu.Lock()

// as an error to be reported.
func ReadFileWithFileInfo(name string) ([]byte, fs.FileInfo, error) {
	f, err := OsOpenFile(name, readMode, 0o666)
	if err != nil {
		return nil, nil, err
	}
	defer f.Close()

	st, err := f.Stat()
	if err != nil {
		return nil, nil, err
	}

	dst := make([]byte, st.Size())
	_, err = io.ReadFull(f, dst)
	return dst, st, err
}

            protected SmbResource adapt(FileEntry e) {
                return mockResource1;
            }
        };

        // When
        iterator.close();

        // Then
        verify(mockDelegate).close();
    }

    /**
     * Test close method propagates exception.
     */
    @Test
    void testCloseWithException() throws CIFSException {
        // Given

        .url(server.url("/"))
        .header("Connection", "close")
        .build()
    val requestB = Request(server.url("/"))
    assertConnectionNotReused(requestA, requestB)
  }

  @Test
  fun connectionsAreNotReusedWithResponseConnectionClose() {
    server.enqueue(
      MockResponse(
        headers = headersOf("Connection", "close"),
        body = "a",
      ),
    )

    /**
     * Closes the underlying CrawlerClient and releases any resources associated with it.
     *
     * @throws Exception if an error occurs during the close operation
     */
    @Override
    public void close() throws Exception {
        client.close();
    }

    /**
     * Returns the underlying CrawlerClient.
     * @return The CrawlerClient instance.
     */

    }
  }

  @Test fun headersEquals() {
    val headers1 =
      Headers
        .Builder()
        .add("Connection", "close")
        .add("Transfer-Encoding", "chunked")
        .build()
    val headers2 =
      Headers
        .Builder()
        .add("Connection", "close")
        .add("Transfer-Encoding", "chunked")
        .build()
    assertThat(headers2).isEqualTo(headers1)

	}
	srv.listenerMutex.Unlock()

	if atomic.AddUint32(&srv.inShutdown, 1) > 1 {
		// shutdown in progress
		return http.ErrServerClosed
	}

	// Close underneath HTTP listener.
	srv.listenerMutex.Lock()
	err := srv.listener.Close()
	srv.listenerMutex.Unlock()
	if err != nil {
		return err
	}

	// Wait for opened connection to be closed up to Shutdown timeout.
	return nil
}