InputStreamThread thread = new InputStreamThread(is, StandardCharsets.UTF_8, 100, callback);
        thread.start();

        assertTrue("Should process all lines within timeout", latch.await(3, TimeUnit.SECONDS));

        thread.join(1000);

        assertEquals("All lines should be processed", 5000, receivedLines.size());
        assertEquals("First line", "Line number 0", receivedLines.get(0));

    val executor =
      ThreadPoolExecutor(
        // corePoolSize:
        0,
        // maximumPoolSize:
        Int.MAX_VALUE,
        // keepAliveTime:
        60L,
        TimeUnit.SECONDS,
        SynchronousQueue(),
        threadFactory,
      )

    override fun nanoTime() = System.nanoTime()

    override fun coordinatorNotify(taskRunner: TaskRunner) {
      taskRunner.notify()

    private static final Logger logger = LogManager.getLogger(ApiExtractor.class);

    /** The URL of the API endpoint. */
    protected String url;

    /** The access timeout in seconds. */
    protected Integer accessTimeout; // sec

    /** The HTTP client used for API calls. */
    protected CloseableHttpClient httpClient;

    /** The connection timeout in milliseconds. */

		memCache:          "Cache memory on the node",
		memAvailable:      "Available memory on the node",
		readsPerSec:       "Reads per second on a drive",
		writesPerSec:      "Writes per second on a drive",
		readsKBPerSec:     "Kilobytes read per second on a drive",
		writesKBPerSec:    "Kilobytes written per second on a drive",
		readsAwait:        "Average time for read requests to be served on a drive",

      "ConnectionReleased",
      "CallEnd",
    )
  }

  @Test
  fun failedCallEventSequence() {
    server.enqueue(
      MockResponse
        .Builder()
        .headersDelay(2, TimeUnit.SECONDS)
        .build(),
    )
    client =
      client
        .newBuilder()
        .readTimeout(Duration.ofMillis(250))
        .build()
    val call =
      client.newCall(
        Request

        this.leaseKey = key;
        this.leaseState = leaseState;
        this.cacheScope = scope;
        this.maxCacheAge = 30000; // 30 seconds default
        this.notificationEnabled = true;
        this.notificationFilter = 0;
    }

    @Override
    public byte[] getName() {
        return CONTEXT_NAME_BYTES;
    }

    /**

	// prepare getElapsedTime() to calculate elapsed time since we started trying formatting disks.
	// All times are rounded to avoid showing milli, micro and nano seconds
	formatStartTime := time.Now().Round(time.Second)
	getElapsedTime := func() string {
		return time.Now().Round(time.Second).Sub(formatStartTime).String()
	}

	var (
		tries   int
		verbose bool
	)

	// Initialize all storage disks

    CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
        handleLeaseBreak(key, newState);
    });
    
    try {
        future.get(5, TimeUnit.SECONDS);  // 5 second timeout
    } catch (TimeoutException e) {
        // Force lease release if break handling times out
        releaseLease(key);
        log.warn("Lease break timeout for key: {}", key);
    }
}
```

import static java.util.concurrent.Executors.newFixedThreadPool;
import static java.util.concurrent.Executors.newScheduledThreadPool;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;

import com.google.common.base.Preconditions;
import com.google.common.base.Stopwatch;
import com.google.common.testing.NullPointerTester;
import com.google.common.testing.TearDown;

        // Scenario 2: Command timeout
        CommandExecutionException timeout =
                new CommandExecutionException("Command execution timed out after 30 seconds", new RuntimeException("Timeout"));
        assertTrue(timeout.getMessage().contains("timed out"));
        assertNotNull(timeout.getCause());

        // Scenario 3: Permission denied