*  **Canceling batches of calls is now the application's responsibility.**
    The API to cancel calls by tag has been removed and replaced with a more
    general mechanism. The dispatcher now exposes all in-flight calls via its
    `runningCalls()` and `queuedCalls()` methods. You can write code that
    selects calls by tag, host, or whatever, and invokes `Call.cancel()` on the
    ones that are no longer necessary.

    )
  }

  /**
   * We don't track the active task in scheduled tasks. This behavior might be a mistake, but it's
   * cumbersome to implement properly because the active task might be a cancel.
   */
  @Test fun scheduledTasksDoesNotIncludeRunningTask() {
    val task =
      object : Task("task one") {
        val schedules = mutableListOf(200.µs)

        override fun runOnce(): Long {

        digest.sign(data, 0, data.length, cancelRequest, null);

        verify(cancelRequest).setSignSeq(10);
        // Sequence should increment by 1 for cancel requests
    }

    @Test
    @DisplayName("Test sign method with null response")
    void testSignWithNullResponse() {
        SMB1SigningDigest digest = new SMB1SigningDigest(testMacSigningKey, false, 10);

        }
    }

    /**
     * Stop proactive health checking
     */
    public void stopProactiveHealthChecking() {
        if (healthCheckTask != null) {
            healthCheckTask.cancel(false);
            healthCheckTask = null;
            log.info("Stopped proactive health checking");
        }
    }

    /**
     * Perform proactive health check on all connections
     */

    
    public void stopWatching(String directoryPath) {
        ChangeNotificationHandle handle = activeWatchers.remove(directoryPath);
        if (handle != null) {
            handle.active = false;
            // Cancel any pending notifications
            cancelNotification(handle);
        }
    }
    
    private void startAsyncNotification(ChangeNotificationHandle handle) {
        CompletableFuture.runAsync(() -> {

   * occur after a call is canceled. Typically cancellation takes effect when an expensive I/O
   * operation is required.
   *
   * This is invoked at most once, even if [Call.cancel] is invoked multiple times. It may be
   * invoked at any point in a call's life, including before [callStart] and after [callEnd].
   */
  open fun canceled(call: Call) {
  }

  /**

   * structure is not necessarily related to the processing format.
   *
   * @since 8.0
   */
  public static final byte ETB = 23;

  /**
   * Cancel: A control character used to indicate that the data with which it is sent is in error or
   * is to be disregarded.
   *
   * @since 8.0
   */
  public static final byte CAN = 24;

  /**

    val interceptor =
      Interceptor { chain: Interceptor.Chain ->
        val call = chain.call()
        callRef.set(call)
        assertThat(call.isCanceled()).isFalse()
        call.cancel()
        assertThat(call.isCanceled()).isTrue()
        chain.proceed(chain.request())
      }
    client =
      client
        .newBuilder()
        .addInterceptor(interceptor)
        .build()

            throw new JobProcessingException("Failed to execute a crawl job.", e);
        } finally {
            if (timeoutTask != null && !timeoutTask.isCanceled()) {
                timeoutTask.cancel();
            }
        }

        return resultBuf.toString();

    }

    /**
     * Gets the count of currently running crawler jobs.

            return;
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Closing HTTP client...");
        }
        if (connectionMonitorTask != null) {
            connectionMonitorTask.cancel();
            if (logger.isDebugEnabled()) {
                logger.debug("Connection monitor task cancelled");
            }
        }
        if (httpClient != null) {
            try {