}

  private fun logWithTime(message: String) {
    val startNs = startNs
    val timeMs =
      if (startNs == null) {
        // Event occurred before start, for an example an early cancel.
        0L
      } else {
        TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs)
      }

    logger.invoke("[$timeMs ms] $message")
  }

        .build(),
    )
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    call.cancel()
    call.cancel()
    assertThat(listener.recordedEventTypes()).containsExactly("Canceled")
  }

  private fun assertSuccessfulEventOrder(
    responseMatcher: Matcher<Response?>?,
    emptyBody: Boolean = false,
  ) {

        this.function = function;
        this.primarySetupOffset = NTT_PRIMARY_SETUP_OFFSET;
        this.secondaryParameterOffset = NTT_SECONDARY_PARAMETER_OFFSET;
    }

    /**
     *
     * @return a cancel request
     */
    @Override
    public CommonServerMessageBlockRequest createCancel() {
        return new SmbComNtCancel(getConfig(), (int) getMid());
    }

    @Override

on:
  pull_request:
    branches:
      - master

# This ensures that previous jobs for the PR are canceled when the PR is
# updated.
concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref }}
  cancel-in-progress: true

permissions:
  contents: read

jobs:
  mint-test:
    runs-on: mint
    timeout-minutes: 120
    steps:
      - name: cleanup #https://github.com/actions/checkout/issues/273

	case "Rmdir":
		bucket, prefix := path2BucketObject(r.Filepath)
		if bucket == "" {
			return errors.New("deleting all buckets not allowed")
		}

		cctx, cancel := context.WithCancel(context.Background())
		defer cancel()

		if prefix == "" {
			// if all objects are not deleted yet this call may fail.
			return clnt.RemoveBucket(cctx, bucket)
		}

		objectsCh := make(chan minio.ObjectInfo)

    } finally {
      Thread.interrupted();
    }
  }

  public void testGetCheckedUntimed_cancelled() throws TwoArgConstructorException {
    SettableFuture<String> future = SettableFuture.create();
    future.cancel(true);
    assertThrows(
        CancellationException.class, () -> getChecked(future, TwoArgConstructorException.class));
  }

  public void testGetCheckedUntimed_executionExceptionChecked() {

        int result = request.size();

        // Then
        assertEquals(largeSize, result);
        verify(request, times(1)).size();
    }

    @Test
    @DisplayName("Test createCancel returns cancel request")
    void testCreateCancelReturnsRequest() {
        // Given
        when(request.createCancel()).thenReturn(cancelRequest);

        // When

		sshConfig.PasswordCallback = nil
	}

	sshConfig.AddHostKey(private)

	handleSFTPSession := func(channel ssh.Channel, sconn *ssh.ServerConn) {
		var remoteIP string

		if host, _, err := net.SplitHostPort(sconn.RemoteAddr().String()); err == nil {
			remoteIP = host
		}
		server := sftp.NewRequestServer(channel, NewSFTPDriver(sconn.Permissions, remoteIP), sftp.WithRSAllocator())
		defer server.Close()
		server.Serve()
	}

   * State#RUNNING}. Services that need to cancel startup work can override {@link #doCancelStart}.
   */
  @ForOverride
  protected abstract void doStop();

  /**
   * This method is called by {@link #stopAsync} when the service is still starting (i.e. {@link
   * #startAsync} has been called but {@link #notifyStarted} has not). Subclasses can override the

		Info: dataUsageCacheInfo{
			Name:      dataUsageRoot,
			NextCycle: oldCache.Info.NextCycle,
		},
		Cache: make(map[string]dataUsageEntry, len(oldCache.Cache)),
	}

	// Put all buckets into channel.
	bucketCh := make(chan BucketInfo, len(buckets))

	// Shuffle buckets to ensure total randomness of buckets, being scanned.
	// Otherwise same set of buckets get scanned across erasure sets always.