func (p *xlStorageDiskIDCheck) monitorDiskWritable(ctx context.Context) {
	var (
		// We check every 15 seconds if the disk is writable and we can read back.
		checkEvery = 15 * time.Second

		// If the disk has completed an operation successfully within last 5 seconds, don't check it.
		skipIfSuccessBefore = 5 * time.Second
	)

	// if disk max timeout is smaller than checkEvery window

                assertEquals(result, crawlingInfoHelper.generateId(dataMap));
                counter.incrementAndGet();
            });
        }
        pool.shutdown();
        pool.awaitTermination(10, TimeUnit.SECONDS);
        assertEquals(1000, counter.get());
    }

    public void test_getCanonicalSessionId() {
        assertEquals("session123", crawlingInfoHelper.getCanonicalSessionId("session123"));

    /**
     * Retrieve the last time the file represented by this
     * <code>SmbResource</code> was modified. The value returned is suitable for
     * constructing a {@link java.util.Date} object (i.e. seconds since Epoch
     * 1970). Times should be the same as those reported using the properties
     * dialog of the Windows Explorer program.
     *
     * @return The number of milliseconds since the 00:00:00 GMT, January 1,

crawler.ignore.robots.tags=false
# Whether to ignore content exceptions during crawling.
crawler.ignore.content.exception=true
# HTTP status codes considered as failure URLs.
crawler.failure.url.status.codes=404
# Interval (seconds) for system monitor during crawling.
crawler.system.monitor.interval=60
# Whether to ignore idle threads in hot thread monitoring.
crawler.hotthread.ignore_idle_threads=true
# Interval for hot thread monitoring (e.g., 500ms).

     *     the `streamId`.
     * @param protocol an ALPN protocol, such as `h2`.
     * @param host an IP address or hostname.
     * @param port the IP port associated with the service.
     * @param maxAge time in seconds that this alternative is considered fresh.
     */
    fun alternateService(
      streamId: Int,
      origin: String,
      protocol: ByteString,
      host: String,
      port: Int,
      maxAge: Long,

 *  New: Honor the `Retry-After` response header. HTTP 503 (Unavailable)
    responses are retried automatically if this header is present and its delay
    is 0 seconds. HTTP 408 (Client Timeout) responses are retried automatically
    if the header is absent or its delay is 0 seconds.
 *  New: Allow request bodies for all HTTP methods except GET and HEAD.
 *  New: Automatic module name of `okhttp3` for use with the Java Platform
    Module System.

              <sourceLevel>1.8</sourceLevel>
              <!-- Keep these timeouts very large because, if we hit the timeout, the tests silently pass :( -->
              <testTimeOut>86400 <!-- seconds --></testTimeOut>
              <testMethodTimeout>1440 <!-- minutes --></testMethodTimeout>
              <!-- Presumably we want watchFileChanges=false here, since we want it for compile: -->

     * Shutdown the audit logger gracefully
     */
    public void shutdown() {
        shutdown = true;
        logExecutor.shutdown();
        try {
            if (!logExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                logExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            logExecutor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }

            }).start();
        }

        // Start all threads simultaneously
        startLatch.countDown();

        // Wait for completion
        assertTrue(completeLatch.await(5, TimeUnit.SECONDS));

        // Authenticator should be closed
        assertTrue(auth.isClosed());
    }

    /**
     * Test password security with char array constructor variations
     */
    @Test

    public void close() throws Exception {
        if (executorService != null) {
            try {
                executorService.shutdown();
                executorService.awaitTermination(60, TimeUnit.SECONDS);
            } catch (final InterruptedException e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Interrupted.", e);
                }
            } finally {